1-100.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "초보자를 위한 파이썬 300제.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "8R_Cje8N_fGF",
        "k1TL1DVncWTa",
        "cLAN0U560ZCZ",
        "iNjvnKRi0BDO",
        "TTCsTuon0JaA",
        "BbXdVyk30vXX"
      ],
      "authorship_tag": "ABX9TyMvKlmEuCh+76hDDkF4fsZm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/IsaacTips/Python_300_for_beginners./blob/main/%EC%B4%88%EB%B3%B4%EC%9E%90%EB%A5%BC_%EC%9C%84%ED%95%9C_%ED%8C%8C%EC%9D%B4%EC%8D%AC_300%EC%A0%9C.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8R_Cje8N_fGF"
      },
      "source": [
        "## 01.파이썬 시작하기\r\n",
        "----\r\n",
        "print 함수와 관련된 문제를 풀어봅시다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y2Fu5wmp_lkO"
      },
      "source": [
        "####001~010\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aI6yLB5w_tUu"
      },
      "source": [
        "#### 001 print 기초\r\n",
        "화면에 `Hello World`문자열을 출력하세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nvBvJEX2YYeK",
        "outputId": "6f0c8a2c-5848-4320-f02f-1cb2f2254b52"
      },
      "source": [
        "print(\"Hello World\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zYDZ7xLiBiV4",
        "outputId": "0814e896-fba7-4ab6-a724-5d0e2e84e8c4"
      },
      "source": [
        "print('Hello World')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hl9-eU9b_s8O"
      },
      "source": [
        "#### 002 print 기초\r\n",
        "화면에 `Mary's cosmetics`을 출력하세요. (중간에 '가 있음에 주의하세요)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zXg3vBAIBhwp",
        "outputId": "879783a9-7ccf-4685-a8f4-2597822d7906"
      },
      "source": [
        "print(\"Mary's cosmetics\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mary's cosmetics\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2dAhflxa_eP-"
      },
      "source": [
        "#### 003 print 기초\r\n",
        "화면에 아래 문장을 출력하세요. (중간에 \"가 있음에 주의하세요.)\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "신씨가 소리질렀다. \"도둑이야\".\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vfz5BYzWY7VG",
        "outputId": "93c53fa9-09b7-43a7-f612-fc0bd83027bb"
      },
      "source": [
        "print('신씨가 소리질렀다. \"도둑이야\".')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "신씨가 소리질렀다. \"도둑이야\".\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qroyXKRyCKyn"
      },
      "source": [
        "####004 print 기초\r\n",
        "화면에 `\"C:\\Windows\"`를 출력하세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LW5ld3AjCEqV",
        "outputId": "90e2839c-d868-4190-914f-f04cb81d48f9"
      },
      "source": [
        "print('\"C:\\Windows\"')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\"C:\\Windows\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AMRqY9_-CtA7"
      },
      "source": [
        "#### 005 print 탭과 줄바꿈\r\n",
        "다음 코드를 실행해보고 \\t와 \\n의 역할을 설명해보세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s9zHshlbC2ZF"
      },
      "source": [
        "\r\n",
        "\r\n",
        "```\r\n",
        "print(\"안녕하세요.\\n만나서\\t\\t반갑습니다.\")\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fVN2gYLXCq9c",
        "outputId": "32802244-f48a-469c-8276-99c1d64d1933"
      },
      "source": [
        "print(\"안녕하세요.\\n만나서\\t\\t반갑습니다.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "안녕하세요.\n",
            "만나서\t\t반갑습니다.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ukpVT-GfDAlO"
      },
      "source": [
        "`\\t`는 탭을 의미하고 `\\n`은 줄바꿈을 의미한다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7sXWZFG7DcPj"
      },
      "source": [
        "#### 006 print 여러 데이터 출력\r\n",
        "print 함수에 두 개의 단어를 입력한 예제입니다. 아래 코드의 출력 결과를 예상해봅시다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r36WuAfHDcVT"
      },
      "source": [
        "\r\n",
        "\r\n",
        "```\r\n",
        "print (\"오늘은\", \"일요일\")\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QEo2aGvuDpN6",
        "outputId": "7c21b018-8021-4cfc-bd9a-1f683b2d9a06"
      },
      "source": [
        "print (\"오늘은\", \"일요일\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "오늘은 일요일\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UYx1-axqDnys"
      },
      "source": [
        "`print`함수에서 쉼표는 구분하는 것으로써 `오늘은` 다음에 한칸 뛰고 `일요일`이 출력된다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uzkFGZ2UD_Rp"
      },
      "source": [
        "#### 007 print 기초\r\n",
        "print() 함수를 사용하여 다음과 같이 출력하세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zPA6PpfIEFI-"
      },
      "source": [
        "\r\n",
        "\r\n",
        "```\r\n",
        "naver;kakao;sk;samsung\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YMo2XGe3Cq_u",
        "outputId": "5c8c4d4a-c492-4230-ef33-a325336c7f0b"
      },
      "source": [
        "print(\"naver;kakao;sk;samsung\")\r\n",
        "print(\"naver\", \"kakao\", \"sk\", \"samsung\", sep=\";\")\r\n",
        "#print 함수의 sep 인자로 \";\"를 입력하면 출력되는 값들 사이에 한 칸의 공백대신 세미콜론이 출력됩니다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "naver;kakao;sk;samsung\n",
            "naver;kakao;sk;samsung\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IZQs-NL3Eh5G"
      },
      "source": [
        "#### 008 print 기초\r\n",
        "print() 함수를 사용하여 다음과 같이 출력하세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "je6V9yEZEj9F"
      },
      "source": [
        "\r\n",
        "\r\n",
        "```\r\n",
        "naver/kakao/sk/samsung\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x1_lt3AeCrCE",
        "outputId": "d6ca3ec0-cd8c-4269-f32e-7149d1b1ecb8"
      },
      "source": [
        "print(\"naver\", \"kakao\", \"sk\", \"samsung\", sep=\"/\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "naver/kakao/sk/samsung\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlBsPj6JE91C"
      },
      "source": [
        "#### 009 print 줄바꿈\r\n",
        "다음 코드를 수정하여 줄바꿈이 없이 출력하세요. (힌트: end='') print 함수는 두 번 사용합니다. 세미콜론 (;)은 한줄에 여러 개의 명령을 작성하기 위해 사용합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2BTEzbdQFZJ9"
      },
      "source": [
        "\r\n",
        "\r\n",
        "```\r\n",
        "print(\"first\");print(\"second\")\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s_gtYsfzCrEX",
        "outputId": "4b834f21-988d-4f47-e956-e2e050c7232a"
      },
      "source": [
        "print(\"first\", end=' ');print(\"second\")\r\n",
        "#end함수 활용"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "first second\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k63fGkMmGJef"
      },
      "source": [
        "#### 010 연산 결과 출력\r\n",
        "$$\r\n",
        "\\frac 5 3\r\n",
        "$$\r\n",
        "<center>의 결과를 화면에 출력하세요.</center>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SKACDvIjCrGl",
        "outputId": "a6df4bb8-f052-4153-afd4-4adaa13aee0f"
      },
      "source": [
        "print(5/3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.6666666666666667\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k1TL1DVncWTa"
      },
      "source": [
        "## 02. 파이썬 변수\r\n",
        "----\r\n",
        "파이썬 변수는 자주 사용되는 값을 바인딩합니다. 파이썬 변수의 개념을 이해하고 문제를 풀어봅시다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "STrbQ5qkcpuV"
      },
      "source": [
        "#### 011 변수 사용하기\r\n",
        "삼성전자라는 변수로 50,000원을 바인딩해보세요. 삼성전자 주식 10주를 보유하고 있을 때 총 평가금액을 출력하세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kI_NtXrFcV2C",
        "outputId": "e9394aa0-a3e8-469f-d749-17447930e798"
      },
      "source": [
        "삼성전자 = 50000\r\n",
        "총평가금액 = 삼성전자 * 10\r\n",
        "print(총평가금액)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "500000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OHU0Z3bAdFK5"
      },
      "source": [
        "#### 012 변수 사용하기\r\n",
        "다음 표는 삼성전자의 일부 투자정보입니다. 변수를 사용해서 시가총액, 현재가, PER 등을 바인딩해보세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rdt-ucBCdLLA"
      },
      "source": [
        "|항목|값|\r\n",
        "|------|----|\r\n",
        "|시가총액|298조|\r\n",
        "|현재가|50000|\r\n",
        "|PER|15.79|\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IfqgwtPYCrI1",
        "outputId": "115f30ef-9962-4e41-d4e5-7f85f5ad068a"
      },
      "source": [
        "시가총액 = 298000000000000\r\n",
        "현재가 = 50000\r\n",
        "PER = 15.79\r\n",
        "print(시가총액, type(시가총액))\r\n",
        "print(현재가, type(현재가))\r\n",
        "print(PER, type(PER))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "298000000000000 <class 'int'>\n",
            "50000 <class 'int'>\n",
            "15.79 <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BIw1-jvSeRGj"
      },
      "source": [
        "#### 013 문자열 출력\r\n",
        "변수 s와 t에는 각각 문자열이 바인딩 되어있습니다.\r\n",
        "\r\n",
        "```\r\n",
        ">> s = \"hello\"\r\n",
        ">> t = \"python\"\r\n",
        "```\r\n",
        "두 변수를 이용하여 아래와 같이 출력해보세요.\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "hello! python\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "imwPZttxCrK9",
        "outputId": "6b67a926-7fef-4fd1-84b4-7027b046d9e1"
      },
      "source": [
        "s = \"hello\"\r\n",
        "t = \"python\"\r\n",
        "print(s+'!', t)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello! python\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LFvDybUsfL60"
      },
      "source": [
        "####014 파이썬을 이용한 값 계산\r\n",
        "아래 코드의 실행 결과를 예상해보세요.\r\n",
        "\r\n",
        "```\r\n",
        ">> 2 + 2 * 3 \r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NgL5ZNO5CrNJ",
        "outputId": "9f30c4fe-94f4-43c2-d6ff-64fca9f1455e"
      },
      "source": [
        "print(2 + 2 * 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20aS1jfDf_Mk"
      },
      "source": [
        "#### 015 type 함수\r\n",
        "type() 함수는 데이터 타입을 판별합니다. 변수 a에는 128 숫자가 바인딩돼 있어 type 함수가 int (정수)형임을 알려줍니다.\r\n",
        "\r\n",
        "```\r\n",
        ">> a = 128\r\n",
        ">> print (type(a))\r\n",
        "<class 'int'>\r\n",
        "```\r\n",
        "아래 변수에 바인딩된 값의 타입을 판별해보세요.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        ">> a = \"132\"\r\n",
        "```\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O-DapQ7MCi85",
        "outputId": "e0ddd576-a5ad-45fe-9f6d-2aa9128e5394"
      },
      "source": [
        "a = \"132\"\r\n",
        "print(type(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZtbkDCMwgWHf"
      },
      "source": [
        "####016 문자열을 정수로 변환\r\n",
        "문자열 '720'를 정수형으로 변환해보세요.\r\n",
        "\r\n",
        "```\r\n",
        ">> num_str = \"720\"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4tP60-nKgO-W",
        "outputId": "4b3b0067-8e6d-483d-a60e-ba24d63b91aa"
      },
      "source": [
        "num_str = \"720\"\r\n",
        "num_int = int(num_str)\r\n",
        "print(num_int, type(num_int))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "720 <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gfy3U8GLhOXv"
      },
      "source": [
        "####017 정수를 문자열 100으로 변환\r\n",
        "정수 100을 문자열 '100'으로 변환해보세요.\r\n",
        "\r\n",
        "```\r\n",
        "num = 100\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QhhkrXFFg9Ew",
        "outputId": "b1e1013a-7a4c-4a22-960f-b859aec2a3e7"
      },
      "source": [
        "num = 100\r\n",
        "num_str = str(num)\r\n",
        "print(num_str, type(num_str))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100 <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2O-8O_2lhqls"
      },
      "source": [
        "####018 문자열을 실수로 변환\r\n",
        "문자열 \"15.79\"를 실수(float) 타입으로 변환해보세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nkwdBqjjhgU9",
        "outputId": "9d473d53-d758-45ec-d36e-45b16093d4dd"
      },
      "source": [
        "num_str = \"15.79\"\r\n",
        "num_float = float(num_str)\r\n",
        "print(num_float, type(num_float))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15.79 <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wv_vyBDiIYP"
      },
      "source": [
        "#### 019 문자열을 정수로 변환\r\n",
        "year라는 변수가 문자열 타입의 연도를 바인딩하고 있습니다.<br>이를 정수로 변환한 후 최근 3년의 연도를 화면에 출력해보세요.\r\n",
        "\r\n",
        "```\r\n",
        "year = \"2020\"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G-6TafLFh_ws",
        "outputId": "864627b2-80cd-4304-e312-a074b467b6da"
      },
      "source": [
        "year = \"2020\"\r\n",
        "year_int = int(year)\r\n",
        "print(year_int - 3, year_int - 2, year_int - 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2017 2018 2019\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I0cZjwZHi7U3"
      },
      "source": [
        "####020 파이썬 계산\r\n",
        "에이컨이 월 48,584원에 무이자 36개월의 조건으로 홈쇼핑에서 판매되고 있습니다. 총 금액은 계산한 후 이를 화면에 출력해보세요. (변수사용하기)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HetznPC_iGQC",
        "outputId": "faa5f569-eccb-48cd-8169-4ff4ec944f97"
      },
      "source": [
        "aircon = 48584\r\n",
        "inter = 36\r\n",
        "price = aircon * inter\r\n",
        "print(price)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1749024\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cLAN0U560ZCZ"
      },
      "source": [
        "## 03. 파이썬 문자열\r\n",
        "----\r\n",
        "파이썬 문자열은 인덱싱, 슬라이싱 기능과 다양한 메서드를 제공합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZnvAq6KYkcYG"
      },
      "source": [
        "####021 ~ 030\r\n",
        "####021 문자열 인덱싱\r\n",
        "letters가 바인딩하는 문자열에서 첫번째와 세번째 문자를 출력하세요.\r\n",
        "\r\n",
        "```\r\n",
        ">> letters = 'python'\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예\r\n",
        "p t\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BwGbehRwkRwd",
        "outputId": "00437196-32a0-45b9-a25e-5fc187324e9e"
      },
      "source": [
        "letters = 'python'\r\n",
        "print(letters[0], letters[2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "p t\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FwLlN3LBlN7u"
      },
      "source": [
        "#### 022 문자열 슬라이싱\r\n",
        "자동차 번호가 다음과 같을 때 뒤에 4자리만 출력하세요.\r\n",
        "\r\n",
        "```\r\n",
        ">> license_plate = \"24가 2210\"\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예: 2210\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rujU6RPxlNe9",
        "outputId": "1f97a05a-43c7-491d-f9cd-4514e6db29ab"
      },
      "source": [
        "license_plate = \"24가 2210\"\r\n",
        "print(license_plate[4:])\r\n",
        "print(license_plate[-4:])\r\n",
        "#음수로도 가능"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2210\n",
            "2210\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y9xQRHKkmI52"
      },
      "source": [
        "#### 023 문자열 인덱싱\r\n",
        "아래의 문자열에서 '홀' 만 출력하세요.\r\n",
        "\r\n",
        "```\r\n",
        ">> string = \"홀짝홀짝홀짝\"\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "홀홀홀\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uw-0CV-rmXUn",
        "outputId": "a4fdf0aa-ae34-44a8-e299-94734887d964"
      },
      "source": [
        "string = \"홀짝홀짝홀짝\"\r\n",
        "print(string[::2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "홀홀홀\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h3lQ_LAMmWnH"
      },
      "source": [
        "#### 024 문자열 슬라이싱\n",
        "문자열을 거꾸로 뒤집어 출력하세요.\n",
        "\n",
        "```\n",
        ">> string = \"PYTHON\"\n",
        "```\n",
        "\n",
        "```\n",
        "실행 예:\n",
        "NOHTYP\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUJOp40smW2k",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4d19c65-a204-486c-ba97-7810a8fc1232"
      },
      "source": [
        "string = \"PYTHON\"\n",
        "print(string[::-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "NOHTYP\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JvFlEBEbsk87"
      },
      "source": [
        "####025 문자열 치환\n",
        "아래의 전화번호에서 하이푼 ('-')을 제거하고 출력하세요.\n",
        "\n",
        "```\n",
        ">> phone_number = \"010-1111-2222\"\n",
        "```\n",
        "\n",
        "```\n",
        "실행 예\n",
        "010 1111 2222\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7G1I5ASqsuqb",
        "outputId": "ffd8e58d-ba1a-4a73-8ca3-bcaef460d89f"
      },
      "source": [
        "phone_number = \"010-1111-2222\"\n",
        "blank_phone_number = phone_number.replace(\"-\", \" \")\n",
        "print(blank_phone_number)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "010 1111 2222\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jWzSsgDIsk_Y"
      },
      "source": [
        "####026 문자열 다루기\n",
        "25번 문제의 전화번호를 아래와 같이 모두 붙여 출력하세요.\n",
        "\n",
        "```\n",
        "실행 예\n",
        "01011112222\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M7StJ5IdtSmc",
        "outputId": "88944a28-7335-471d-8d30-8338e5341ce3"
      },
      "source": [
        "phone_number = \"010-1111-2222\"\n",
        "stick_phone_number = phone_number.replace(\"-\", \"\")\n",
        "print(stick_phone_number)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "01011112222\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CM2PaYYislCA"
      },
      "source": [
        "#### 027 문자열 다루기\n",
        "url 에 저장된 웹 페이지 주소에서 도메인을 출력하세요.\n",
        "\n",
        "```\n",
        ">> url = \"http://sharebook.kr\"\n",
        "```\n",
        "\n",
        "```\n",
        "실행 예:\n",
        "kr\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YeIA3WKaud60",
        "outputId": "6925e62e-288b-4529-d0e3-df322c6fb90b"
      },
      "source": [
        "url = \"http://sharebook.kr\"\n",
        "url_split = url.split('.')\n",
        "print(url_split[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "kr\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hGJisBKPslEF"
      },
      "source": [
        "#### 028 문자열은 immutable\n",
        "아래 코드의 실행 결과를 예상해보세요.\n",
        "\n",
        "```\n",
        ">> lang = 'python'\n",
        ">> lang[0] = 'P'\n",
        ">> print(lang)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 214
        },
        "id": "l-LjVaUFvFTL",
        "outputId": "b3c36b22-a86b-4081-d1bb-b3eaf5d376fc"
      },
      "source": [
        "lang = 'python' \n",
        "lang[0] = 'P' \n",
        "print(lang)\n",
        "#수정불가 "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-af5a43ed7bc4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mlang\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'python'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlang\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'P'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlang\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#수정불가\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xr4ke2r5slGR"
      },
      "source": [
        "#### 029 replace 메서드\n",
        "아래 문자열에서 소문자 'a'를 대문자 'A'로 변경하세요.\n",
        "\n",
        "```\n",
        ">> string = 'abcdfe2a354a32a'\n",
        "```\n",
        "\n",
        "```\n",
        "실행 예:\n",
        "Abcdfe2A354A32A\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "msnVw-ERvcia",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d97ba482-1346-4eb0-9bd3-fa24e7d95bb4"
      },
      "source": [
        "string = 'abcdfe2a354a32a'\n",
        "string_replace = string.replace('a', 'A')\n",
        "print(string_replace)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Abcdfe2A354A32A\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zg5wGiZqslIz"
      },
      "source": [
        "#### 030 replace 메서드\n",
        "아래 코드의 실행 결과를 예상해보세요.\n",
        "\n",
        "```\n",
        ">> string = 'abcd'\n",
        ">> string.replace('b', 'B')\n",
        ">> print(string)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hVN1pSegzKM2",
        "outputId": "65090d0e-8b2c-46aa-8e65-6ede83f5e709"
      },
      "source": [
        "string = 'abcd'031 문자열 합치기\n",
        "아래 코드의 실행 결과를 예상해보세요.\n",
        "string.replace('b', 'B')\n",
        "print(string)\n",
        "#abcd가 그대로 출력됩니다. 왜냐하면 문자열은 변경할 수 없는 자료형이기 때문입니다. replace 메서드를 사용하면 원본은 그대로 둔채로 변경된 새로운 문자열 객체를 리턴해줍니다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "abcd\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b1SczMZ0slK0"
      },
      "source": [
        "#### 031 문자열 합치기\n",
        "아래 코드의 실행 결과를 예상해보세요.\n",
        "\n",
        "```\n",
        ">> a = \"3\"\n",
        ">> b = \"4\"\n",
        ">> print(a + b)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SPSKk0LgkXv1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36378522-8cf9-49cd-a0c3-1c015163a549"
      },
      "source": [
        "a = \"3\"\n",
        "b = \"4\"\n",
        "print(a + b)\n",
        "#두 문자열에 대해 덧셈 기호는 문자열의 연결을 의미합니다. 따라서 \"34\"라는 새로운 문자열이 생성되고 그 값이 print 함수에 의해 화면에 출력됩니다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "34\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i9Kkra3fz6q9"
      },
      "source": [
        "#### 032 문자열 곱하기\n",
        "아래 코드의 실행 결과를 예상해보세요.\n",
        "\n",
        "```\n",
        ">> print(\"Hi\" * 3)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1J8i-FMq0C1l",
        "outputId": "ff75367f-c94a-4f1c-d417-e1fcb05357fc"
      },
      "source": [
        "print(\"Hi\" * 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "HiHiHi\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVCMD9oPz6te"
      },
      "source": [
        "#### 033 문자열 곱하기\n",
        "화면에 '-'를 80개 출력하세요.\n",
        "\n",
        "```\n",
        "실행 예:\n",
        "--------------------------------------------------------------------------------\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6DZoTP240NzO",
        "outputId": "f0f52968-5ce8-45a5-c64a-2cc8c77c1b64"
      },
      "source": [
        "print('-' * 80)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--------------------------------------------------------------------------------\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mefL8Plgz6ys"
      },
      "source": [
        "#### 034 문자열 곱하기\n",
        "변수에 다음과 같은 문자열이 바인딩되어 있습니다.\n",
        "\n",
        "\n",
        "```\n",
        ">>> t1 = 'python'\n",
        ">>> t2 = 'java'\n",
        "```\n",
        "변수에 문자열 더하기와 문자열 곱하기를 사용해서 아래와 같이 출력해보세요\n",
        "\n",
        "```\n",
        "실행 예:\n",
        "python java python java python java python java\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XS8djKnU0hr9",
        "outputId": "b5cf3f3b-886b-40d0-d074-2aa68b1fb7db"
      },
      "source": [
        "t1 = 'python'\n",
        "t2 = 'java'\n",
        "t3 = t1 + ' ' + t2 + ' '\n",
        "print(t3 * 4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "python java python java python java python java \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L_pEjtILz61O"
      },
      "source": [
        "#### 035 문자열 출력\n",
        "변수에 다음과 같이 문자열과 정수가 바인딩되어 있을 때 `% formatting`을 사용해서 다음과 같이 출력해보세요.\n",
        "\n",
        "```\n",
        "name1 = \"김민수\" \n",
        "age1 = 10\n",
        "name2 = \"이철희\"\n",
        "age2 = 13\n",
        "```\n",
        "\n",
        "```\n",
        "이름: 김민수 나이: 10\n",
        "이름: 이철희 나이: 13\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q7KLEM6u1Kvv",
        "outputId": "303fb3e5-b80f-4502-8b63-cfa2232b544f"
      },
      "source": [
        "name1 = \"김민수\" \n",
        "age1 = 10\n",
        "name2 = \"이철희\"\n",
        "age2 = 13\n",
        "\n",
        "print(\"이름: %s 나이: %d\" % (name1, age1))\n",
        "print(\"이름: %s 나이: %d\" % (name2, age2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "이름: 김민수 나이: 10\n",
            "이름: 이철희 나이: 13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pq_3KbIcz631"
      },
      "source": [
        "#### 036 문자열 출력\n",
        "문자열의 format( ) 메서드를 사용해서 035번 문제를 다시 풀어보세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7e9VTPKL2bt4",
        "outputId": "7f338394-bca0-4dae-c1c5-89c677aaed52"
      },
      "source": [
        "name1 = \"김민수\" \n",
        "age1 = 10\n",
        "name2 = \"이철희\"\n",
        "age2 = 13\n",
        "\n",
        "print(\"이름: {} 나이: {}\".format(name1, age1))\n",
        "print(\"이름: {} 나이: {}\".format(name2, age2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "이름: 김민수 나이: 10\n",
            "이름: 이철희 나이: 13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kIFuKPlAz66F"
      },
      "source": [
        "#### 037 문자열 출력\n",
        "파이썬 3.6부터 지원하는 f-string을 사용해서 035번 문제를 다시 풀어보세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I6lYElp43Xzi",
        "outputId": "12c31745-9aa0-467e-ca8d-b1dcac67dcb9"
      },
      "source": [
        "name1 = \"김민수\" \n",
        "age1 = 10\n",
        "name2 = \"이철희\"\n",
        "age2 = 13\n",
        "\n",
        "print(f\"이름: {name1} 나이: {age1}\")\n",
        "print(f\"이름: {name2} 나이: {age2}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "이름: 김민수 나이: 10\n",
            "이름: 이철희 나이: 13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DyTY6ZFz68d"
      },
      "source": [
        "#### 038 컴마 제거하기\n",
        "삼성전자의 상장주식수가 다음과 같습니다. 컴마를 제거한 후 이를 정수 타입으로 변환해보세요.\n",
        "\n",
        "```\n",
        "상장주식수 = \"5,969,782,550\"\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lOU2P2vV4Iqz",
        "outputId": "18ad266f-c174-4ea0-c7e4-028196020d6e"
      },
      "source": [
        "상장주식수 = \"5,969,782,550\"\n",
        "replace = 상장주식수.replace(\",\", \"\")\n",
        "print(replace, type(replace))\n",
        "int = int(replace)\n",
        "print(int, type(int))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5969782550 <class 'str'>\n",
            "5969782550 <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vsllHrEC-tdW"
      },
      "source": [
        "####039 문자열 슬라이싱\n",
        "다음과 같은 문자열에서 '2020/03'만 출력하세요.\n",
        "\n",
        "```\n",
        "분기 = \"2020/03(E) (IFRS연결)\"\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "dUxtiZmj44dm",
        "outputId": "3fcf4290-aa21-4f53-fa34-72a4586fb2c5"
      },
      "source": [
        "분기 = \"2020/03(E) (IFRS연결)\"\n",
        "분기[0:7]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'2020/03'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "98qORqScz6_N"
      },
      "source": [
        "####040 strip 메서드\n",
        "문자열의 좌우의 공백이 있을 때 이를 제거해보세요.\n",
        "\n",
        "```\n",
        "data = \"   삼성전자    \"\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t0OykcaF_SIv",
        "outputId": "0ce138c1-eac5-4b27-93bf-2219e744805c"
      },
      "source": [
        "data = \"   삼성전자    \"\n",
        "data1 = data.strip()\n",
        "print(data1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "삼성전자\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uKFckX1Q_wIo"
      },
      "source": [
        "#### 041 upper 메서드\n",
        "다음과 같은 문자열이 있을 때 이를 대문자 BTC_KRW로 변경하세요.\n",
        "\n",
        "```\n",
        "ticker = \"btc_krw\"\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pgbB-JFJ_nmO",
        "outputId": "5f92279e-cdb0-46f6-acd7-fa6f33746ec0"
      },
      "source": [
        "ticker = \"btc_krw\"\n",
        "ticker1 = ticker.upper()\n",
        "print(ticker1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "BTC_KRW\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B4ebEL2Bz7BP"
      },
      "source": [
        "#### 042 lower 메서드\n",
        "다음과 같은 문자열이 있을 때 이를 소문자 btc_krw로 변경하세요.\n",
        "\n",
        "```\n",
        "ticker = \"BTC_KRW\"\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ujyU07dQAGS5",
        "outputId": "fb841b19-2c7c-4814-8737-1c38320dfb5c"
      },
      "source": [
        "ticker = \"BTC_KRW\"\n",
        "ticker1 = ticker.lower()\n",
        "print(ticker1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "btc_krw\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9qBeufPvz7D0"
      },
      "source": [
        "#### 043 capitalize 메서드\n",
        "문자열 'hello'가 있을 때 이를 'Hello'로 변경해보세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "kTupiM-tBbS_",
        "outputId": "f424fc26-a2cd-4524-ff23-07323a42b065"
      },
      "source": [
        "a = \"hello\"\n",
        "a = a.capitalize()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Hello'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cm82_P0eqRvL"
      },
      "source": [
        "#### 044 endswith 메서드\r\n",
        "파일 이름이 문자열로 저장되어 있을 때 endswith 메서드를 사용해서 파일 이름이 'xlsx'로 끝나는지 확인해보세요.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "file_name = \"보고서.xlsx\"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lCOCpK-bB6wc",
        "outputId": "9cd1bd6f-78a3-4769-bcb3-808dc0f26e11"
      },
      "source": [
        "file_name = \"보고서.xlsx\"\r\n",
        "file_name.endswith(\"xlsx\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQSfHJkkz7GX"
      },
      "source": [
        "#### 046 startswith 메서드\n",
        "파일 이름이 문자열로 저장되어 있을 때 startswith 메서드를 사용해서 파일 이름이 '2020'로 시작하는지 확인해보세요.\n",
        "\n",
        "\n",
        "```\n",
        "file_name = \"2020_보고서.xlsx\"\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8n4ovT91qxwX",
        "outputId": "32b6a6fa-ea62-4eba-eaf5-95dda19f5b75"
      },
      "source": [
        "file_name = \"2020_보고서.xlsx\"\r\n",
        "file_name.startswith(\"2020\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JbQzeom6z7Io"
      },
      "source": [
        "#### 047 split 메서드\r\n",
        "다음과 같은 문자열이 있을 때 공백을 기준으로 문자열을 나눠보세요.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "a = \"hello world\"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z6ISsfeuz1SW",
        "outputId": "f2c4cbe0-9211-4b39-9be4-9fbcc6dba7e2"
      },
      "source": [
        "a = \"hello world\"\r\n",
        "a.split()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['hello', 'world']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ch_mElIArPuT"
      },
      "source": [
        "#### 048 split 메서드\r\n",
        "다음과 같이 문자열이 있을 때 btc와 krw로 나눠보세요.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "ticker = \"btc_krw\"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TQlvOD83EpsL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "523c942d-ce47-478a-8452-5160fafcd004"
      },
      "source": [
        "ticker = \"btc_krw\"\r\n",
        "ticker.split(\"_\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['btc', 'krw']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7F-EuWz9rbqE"
      },
      "source": [
        "#### 049 split 메서드\r\n",
        "다음과 같이 날짜를 표현하는 문자열이 있을 때 연도, 월, 일로 나눠보세요.\r\n",
        "\r\n",
        "```\r\n",
        "date = \"2020-05-01\"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vD1MmytAraVq",
        "outputId": "940d3f5d-2f39-4e9c-bd13-376bb5d37385"
      },
      "source": [
        "date = \"2020-05-01\"\r\n",
        "date.split(\"-\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['2020', '05', '01']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h64925ynrulv"
      },
      "source": [
        "#### 050 rstrip 메서드\r\n",
        "문자열의 오른쪽에 공백이 있을 때 이를 제거해보세요.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "data = \"039490     \"\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Id_7kBCrlg1",
        "outputId": "8a309fd8-1bf3-40f1-b26a-209426923264"
      },
      "source": [
        "data = \"039490     \"\r\n",
        "data.rstrip(\" \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'039490'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iNjvnKRi0BDO"
      },
      "source": [
        "## 04. 파이썬 리스트\r\n",
        "----\r\n",
        "파이선 리스트는 순서가 있고 수정 가능한 자료구조입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lghbB02Ar-XT"
      },
      "source": [
        "#### 051 리스트 생성\r\n",
        "2016년 11월 영화 예매 순위 기준 top3는 다음과 같습니다. 영화 제목을 movie_rank 이름의 리스트에 저장해보세요. (순위 정보는 저장하지 않습니다.)\r\n",
        "\r\n",
        "|순위|영화|\r\n",
        "|------|---|\r\n",
        "|1|닥터 스트레인지|\r\n",
        "|2|스플릿|\r\n",
        "|3|럭키|"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LjzQjpoPr1uV",
        "outputId": "2cceb776-265a-4061-a6ab-c2d544d6fb9f"
      },
      "source": [
        "movie_rank = [\"닥터 스트레인지\", \"스플릿\", \"럭키\"]\r\n",
        "movie_rank"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['닥터 스트레인지', '스플릿', '럭키']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m7wa0p6kshWP"
      },
      "source": [
        "#### 052 리스트에 원소 추가\r\n",
        "051의 movie_rank 리스트에 \"배트맨\"을 추가하라."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uj7ie2VWsaBX",
        "outputId": "d1e84db5-8e59-46f2-85fe-9bbffd968345"
      },
      "source": [
        "movie_rank.append(\"배트맨\")\r\n",
        "movie_rank"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['닥터 스트레인지', '스플릿', '럭키', '배트맨']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZjBhcZGzsxEj"
      },
      "source": [
        "#### 053\r\n",
        "movie_rank 리스트에는 아래와 같이 네 개의 영화 제목이 바인딩되어 있다. \"슈퍼맨\"을 \"닥터 스트레인지\"와 \"스플릿\" 사이에 추가하라.\r\n",
        "\r\n",
        "```\r\n",
        "movie_rank = ['닥터 스트레인지', '스플릿', '럭키', '배트맨']\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pP6tuC72so7K",
        "outputId": "099c874b-1b10-41bf-d573-92aa465b855f"
      },
      "source": [
        "movie_rank = ['닥터 스트레인지', '스플릿', '럭키', '배트맨']\r\n",
        "movie_rank.insert(1, \"슈퍼맨\")\r\n",
        "movie_rank"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['닥터 스트레인지', '슈퍼맨', '스플릿', '럭키', '배트맨']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9L_BTe93tWEH"
      },
      "source": [
        "#### 054\r\n",
        "movie_rank 리스트에서 '럭키'를 삭제하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "movie_rank = ['닥터 스트레인지', '슈퍼맨', '스플릿', '럭키', '배트맨']\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eUh2-N6LtcvP",
        "outputId": "355b03c3-bb81-4481-a878-c7c74fa2e7cc"
      },
      "source": [
        "movie_rank = ['닥터 스트레인지', '슈퍼맨', '스플릿', '럭키', '배트맨']\r\n",
        "movie_rank.remove(\"럭키\")\r\n",
        "movie_rank"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['닥터 스트레인지', '슈퍼맨', '스플릿', '배트맨']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zk4gJQhItWR3"
      },
      "source": [
        "#### 055\r\n",
        "movie_rank 리스트에서 '스플릿' 과 '배트맨'을 를 삭제하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "movie_rank = ['닥터 스트레인지', '슈퍼맨', '스플릿', '배트맨']\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J2gM1Jmwtwpa",
        "outputId": "7873ecf9-c12a-42cd-8717-79dd257fd3ed"
      },
      "source": [
        "movie_rank = ['닥터 스트레인지', '슈퍼맨', '스플릿', '배트맨']\r\n",
        "del movie_rank[2]\r\n",
        "del movie_rank[2]\r\n",
        "movie_rank"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['닥터 스트레인지', '슈퍼맨']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "18dblztQtwG7"
      },
      "source": [
        "#### 056\r\n",
        "lang1과 lang2 리스트가 있을 때 lang1과 lang2의 원소를 모두 갖고 있는 langs 리스트를 만들어라.\r\n",
        "\r\n",
        "```\r\n",
        "lang1 = [\"C\", \"C++\", \"JAVA\"]\r\n",
        "lang2 = [\"Python\", \"Go\", \"C#\"]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        ">> langs\r\n",
        "['C', 'C++', 'JAVA', 'Python', 'Go', 'C#']\r\n",
        "```\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lIdsialWtwOL",
        "outputId": "545c2211-32fc-43c2-af62-1965efa42447"
      },
      "source": [
        "lang1 = [\"C\", \"C++\", \"JAVA\"]\r\n",
        "lang2 = [\"Python\", \"Go\", \"C#\"]\r\n",
        "langs = lang1 + lang2\r\n",
        "langs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'C++', 'JAVA', 'Python', 'Go', 'C#']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G2u8u93OtWUP"
      },
      "source": [
        "#### 057\r\n",
        "다음 리스트에서 최댓값과 최솟값을 출력하라. (힌트: min(), max() 함수 사용)\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "nums = [1, 2, 3, 4, 5, 6, 7]\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "max:  7\r\n",
        "min:  1\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hMdsxEX4ua7q",
        "outputId": "58223346-daa3-4cb2-96e6-a20f9ee8951e"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5, 6, 7]\r\n",
        "nums_max = max(nums)\r\n",
        "nums_min = min(nums)\r\n",
        "print(\"max: \", nums_max)\r\n",
        "print(\"min: \", nums_min)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "max:  7\n",
            "min:  1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AjI1CEF8tWW0"
      },
      "source": [
        "#### 058\r\n",
        "다음 리스트의 합을 출력하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "nums = [1, 2, 3, 4, 5]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "15\r\n",
        "```\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cVc6Mizau9gG",
        "outputId": "69f4f20e-a948-4566-83ba-66f4292a1aa2"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5]\r\n",
        "print(sum(nums))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXDXqrPXtWZQ"
      },
      "source": [
        "#### 059\r\n",
        "다음 리스트에 저장된 데이터의 개수를 화면에 구하하라.\r\n",
        "\r\n",
        "```\r\n",
        "cook = [\"피자\", \"김밥\", \"만두\", \"양념치킨\", \"족발\", \"피자\", \"김치만두\", \"쫄면\", \"쏘세지\", \"라면\", \"팥빙수\", \"김치전\"]\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "19nPljGgvKj4",
        "outputId": "afc6e995-7069-4395-fc95-bad4d4656d92"
      },
      "source": [
        "cook = [\"피자\", \"김밥\", \"만두\", \"양념치킨\", \"족발\", \"피자\", \"김치만두\", \"쫄면\", \"쏘세지\", \"라면\", \"팥빙수\", \"김치전\"]\r\n",
        "len(cook)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FYoKIOEEtWbd"
      },
      "source": [
        "#### 060\r\n",
        "다음 리스트의 평균을 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "nums = [1, 2, 3, 4, 5]\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "3.0\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bnSCmV7-ve7b",
        "outputId": "6cf2c139-3246-4ade-9898-9359b5110fb6"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5]\r\n",
        "average = sum(nums) / len(nums)\r\n",
        "print(average)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pJvp_YUItWd8"
      },
      "source": [
        "#### 061\r\n",
        "price 변수에는 날짜와 종가 정보가 저장돼 있다. 날짜 정보를 제외하고 가격 정보만을 출력하라. (힌트 : 슬라이싱)\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "price = ['20180728', 100, 130, 140, 150, 160, 170]\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "출력 예시:\r\n",
        "[100, 130, 140, 150, 160, 170]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rPZJiLvlv0pH",
        "outputId": "dc61baf1-5bbd-4b57-d8ff-1a1881be8ffd"
      },
      "source": [
        "price = ['20180728', 100, 130, 140, 150, 160, 170]\r\n",
        "price[1:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[100, 130, 140, 150, 160, 170]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wfh7PL0KtWgN"
      },
      "source": [
        "#### 062\r\n",
        "슬라이싱을 사용해서 홀수만 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "[1, 3, 5, 7, 9]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mjq_JYWZwQpS",
        "outputId": "36a79c9c-9175-43aa-94a5-1a3e7b177db4"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\r\n",
        "nums[::2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, 7, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M7o7U-i8tWim"
      },
      "source": [
        "#### 063\r\n",
        "슬라이싱을 사용해서 짝수만 출력하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "[2, 4, 6, 8, 10]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "znAvmmlIwoRW",
        "outputId": "16f65029-576f-4dc8-ff3e-e861b07234ed"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\r\n",
        "nums[1::2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4, 6, 8, 10]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fy3i3xmywd3N"
      },
      "source": [
        "#### 064\r\n",
        "슬라이싱을 사용해서 리스트의 숫자를 역 방향으로 출력하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "nums = [1, 2, 3, 4, 5]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "[5, 4, 3, 2, 1]\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sLZ7p_YMw5R5",
        "outputId": "af93c003-9605-4296-fb93-b979c3008484"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5]\r\n",
        "nums[::-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 4, 3, 2, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GDaHqds6wd5r"
      },
      "source": [
        "#### 065\r\n",
        "interest 리스트에는 아래의 데이터가 바인딩되어 있다.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "interest = ['삼성전자', 'LG전자', 'Naver']\r\n",
        "```\r\n",
        "interest 리스트를 사용하여 아래와 같이 화면에 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "출력 예시:\r\n",
        "삼성전자 Naver\r\n",
        "```\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FrZELrr1xI1b",
        "outputId": "7c544ab3-2f85-43aa-8754-28a4cdb9500c"
      },
      "source": [
        "interest = ['삼성전자', 'LG전자', 'Naver']\r\n",
        "print(interest[0], interest[2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "삼성전자 Naver\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ont7sIRrwd8g"
      },
      "source": [
        "#### 066 join 메서드\r\n",
        "interest 리스트에는 아래의 데이터가 바인딩되어 있다.\r\n",
        "\r\n",
        "```\r\n",
        "interest = ['삼성전자', 'LG전자', 'Naver', 'SK하이닉스', '미래에셋대우']\r\n",
        "```\r\n",
        "\r\n",
        "interest 리스트를 사용하여 아래와 같이 화면에 출력하라.\r\n",
        "```\r\n",
        "출력 예시:\r\n",
        "삼성전자 LG전자 Naver SK하이닉스 미래에셋대우\r\n",
        "```\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n5hv0Yj3xgqA",
        "outputId": "87bb8a97-132f-4000-d721-b2f91d2fff71"
      },
      "source": [
        "interest = ['삼성전자', 'LG전자', 'Naver', 'SK하이닉스', '미래에셋대우']\r\n",
        "print(\" \".join(interest))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "삼성전자 LG전자 Naver SK하이닉스 미래에셋대우\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6WZOCWPSyBfM"
      },
      "source": [
        "#### 067 join 메서드\r\n",
        "interest 리스트에는 아래의 데이터가 바인딩되어 있다.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "interest = ['삼성전자', 'LG전자', 'Naver', 'SK하이닉스', '미래에셋대우']\r\n",
        "```\r\n",
        "interest 리스트를 사용하여 아래와 같이 화면에 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "출력 예시:\r\n",
        "삼성전자/LG전자/Naver/SK하이닉스/미래에셋대우\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jPYY5w7jx6LD",
        "outputId": "fb6094db-a2bd-48fa-df9f-777c1f442830"
      },
      "source": [
        "interest = ['삼성전자', 'LG전자', 'Naver', 'SK하이닉스', '미래에셋대우']\r\n",
        "print(\"/\".join(interest))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "삼성전자/LG전자/Naver/SK하이닉스/미래에셋대우\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9m_gTOtJwd_F"
      },
      "source": [
        "#### 068 join 메서드\r\n",
        "interest 리스트에는 아래의 데이터가 바인딩되어 있다.\r\n",
        "\r\n",
        "```\r\n",
        "interest = ['삼성전자', 'LG전자', 'Naver', 'SK하이닉스', '미래에셋대우']\r\n",
        "```\r\n",
        "join() 메서드를 사용해서 interest 리스트를 아래와 같이 화면에 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "출력 예시:\r\n",
        "삼성전자\r\n",
        "LG전자\r\n",
        "Naver\r\n",
        "SK하이닉스\r\n",
        "미래에셋대우\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aDBI_8gryZpA",
        "outputId": "52a660db-0fdf-49cd-aa90-869075cc70c8"
      },
      "source": [
        "interest = ['삼성전자', 'LG전자', 'Naver', 'SK하이닉스', '미래에셋대우']\r\n",
        "print(\"\\n\".join(interest))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "삼성전자\n",
            "LG전자\n",
            "Naver\n",
            "SK하이닉스\n",
            "미래에셋대우\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loj5mjCAyZHJ"
      },
      "source": [
        "#### 069 문자열 split 메서드\r\n",
        "회사 이름이 슬래시 ('/')로 구분되어 하나의 문자열로 저장되어 있다.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "string = \"삼성전자/LG전자/Naver\"\r\n",
        "```\r\n",
        "이를 interest 이름의 리스트로 분리 저장하라.\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시\r\n",
        ">> print(interest)\r\n",
        "['삼성전자', 'LG전자', 'Naver']\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gGrUDBJeyZSJ",
        "outputId": "e31d3c2f-fe51-43fc-9999-3d8524b5116e"
      },
      "source": [
        "string = \"삼성전자/LG전자/Naver\"\r\n",
        "interest = string.split(\"/\")\r\n",
        "interest"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['삼성전자', 'LG전자', 'Naver']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdYtJ5n6weBj"
      },
      "source": [
        "#### 070 리스트 정렬\r\n",
        "리스트에 있는 값을 오름차순으로 정렬하세요.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "data = [2, 4, 3, 1, 5, 10, 9]\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lR9UxEQgzvht",
        "outputId": "92893718-9313-407f-8b95-4ee3d400a4d3"
      },
      "source": [
        "data = [2, 4, 3, 1, 5, 10, 9]\r\n",
        "data.sort()\r\n",
        "data"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5, 9, 10]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TTCsTuon0JaA"
      },
      "source": [
        "##05. 파이썬 튜플\r\n",
        "--------\r\n",
        "파이썬 튜플은 순서가 있지만 수정 불가능한 자료구조입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BbXdVyk30vXX"
      },
      "source": [
        "#### 071\r\n",
        "my_variable 이름의 비어있는 튜플을 만들라."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NGhrB-Wi0I7w"
      },
      "source": [
        "my_variable = ()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TfGc-e0y09iz"
      },
      "source": [
        "#### 072\r\n",
        "2016년 11월 영화 예매 순위 기준 top3는 다음과 같다. 영화 제목을 movie_rank 이름의 튜플에 저장하라. (순위 정보는 저장하지 않는다.)\r\n",
        "\r\n",
        "|순위|영화|\r\n",
        "|------|---|\r\n",
        "|1|닥터 스트레인지|\r\n",
        "|2|스플릿|\r\n",
        "|3|럭키|\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w4vPr1U0z4dN"
      },
      "source": [
        "movie_rank = (\"닥터 스트레인지\", \"스플릿\", \"럭키\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HrJwwvuLweED"
      },
      "source": [
        "#### 073\r\n",
        "숫자 1 이 저장된 튜플을 생성하라."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YhMoJzu_1Sf_",
        "outputId": "fd93ea4f-f382-47e0-b762-42f571e283d4"
      },
      "source": [
        "tuple = (1)\r\n",
        "type (tuple)\r\n",
        "#아래와 같이 괄호와 함께 하나의 정숫값을 저장하면 튜플이 정의 될 것같지만 그렇지 않습니다. type()을 출력해보면 파이썬은 튜플이 아닌 정수로 인식합니다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xMwHrlck1pe4"
      },
      "source": [
        "tuple = (1, )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ncwgPllVweGo"
      },
      "source": [
        "#### 074\r\n",
        "다음 코드를 실행해보고 오류가 발생하는 원인을 설명하라.\r\n",
        "\r\n",
        "```\r\n",
        ">> t = (1, 2, 3)\r\n",
        ">> t[0] = 'a'\r\n",
        "Traceback (most recent call last):\r\n",
        "  File \"<pyshell#46>\", line 1, in <module>\r\n",
        "    t[0] = 'a'\r\n",
        "TypeError: 'tuple' object does not support item assignment\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aO9hnAm715Xc",
        "outputId": "7a5bfedf-018f-4774-fe82-536003fb435d"
      },
      "source": [
        "t = (1, 2, 3)\r\n",
        "t[0] = 'a'\r\n",
        "#튜플은 원소 값을 변경할 수 없다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-57-30ae5ed3acb9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'a'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0fp0W2v6weJQ"
      },
      "source": [
        "#### 075\r\n",
        "아래와 같이 t에는 1, 2, 3, 4 데이터가 바인딩되어 있다. t가 바인딩하는 데이터 타입은 무엇인가?\r\n",
        "\r\n",
        "```\r\n",
        "t = 1, 2, 3, 4\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qWeqelmL2Iw9",
        "outputId": "cf581d5f-ac5b-4962-d7c9-bd23dd72f5df"
      },
      "source": [
        "t = 1, 2, 3, 4\r\n",
        "type(t)\r\n",
        "#원칙적으로 튜플은 괄호와 함께 데이터를 정의해야 하지만, 사용자 편의를 위해 괄호 없이도 동작한다."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qTHGu-n8weMC"
      },
      "source": [
        "#### 076\r\n",
        "변수 t에는 아래와 같은 값이 저장되어 있다. 변수 t가 ('A', 'b', 'c') 튜플을 가리키도록 수정 하라.\r\n",
        "\r\n",
        "```\r\n",
        "t = ('a', 'b', 'c')\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sTjBYbv32Zig",
        "outputId": "d45de157-3dee-42df-b05d-9177f0093559"
      },
      "source": [
        "t = ('a', 'b', 'c')\r\n",
        "#튜플의 값은 변경할 수 없기 때문에, 새로운 튜플을 만들고 t 라는 변수를 업데이트 해야 한다. 기존의 튜플 ('a', 'b', 'c')은 자동으로 삭제된다.\r\n",
        "t = ('A', 'b', 'c')\r\n",
        "t"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('A', 'b', 'c')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o79QkMLiweOz"
      },
      "source": [
        "#### 077\r\n",
        "다음 튜플을 리스트로 변환하라.\r\n",
        "\r\n",
        "```\r\n",
        "interest = ('삼성전자', 'LG전자', 'SK Hynix')\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mgW8TY-iwc-U",
        "outputId": "98f572e2-10a5-40d4-8c71-8297bdeee6fd"
      },
      "source": [
        "interest = ('삼성전자', 'LG전자', 'SK Hynix')\r\n",
        "interest_list = list(interest)\r\n",
        "interest_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['삼성전자', 'LG전자', 'SK Hynix']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fWxNd1i93KgH"
      },
      "source": [
        "#### 078\r\n",
        "다음 리스트를 튜플로 변경하라.\r\n",
        "\r\n",
        "```\r\n",
        "interest = ['삼성전자', 'LG전자', 'SK Hynix']\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O050NODs3O2X",
        "outputId": "8c18905b-b030-4a3e-c489-6b20cc3622a8"
      },
      "source": [
        "interest = ['삼성전자', 'LG전자', 'SK Hynix']\r\n",
        "interest_tuple = tuple(interest)\r\n",
        "interest_tuple"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('삼성전자', 'LG전자', 'SK Hynix')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pvg4Q17l4VBC"
      },
      "source": [
        "#### 079 튜플 언팩킹\r\n",
        "다음 코드의 실행 결과를 예상하라.\r\n",
        "\r\n",
        "```\r\n",
        "temp = ('apple', 'banana', 'cake')\r\n",
        "a, b, c = temp\r\n",
        "print(a, b, c)\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rsmy15QT3igL",
        "outputId": "8642d181-8ea0-4e45-fc5a-e96845b6e215"
      },
      "source": [
        "temp = ('apple', 'banana', 'cake')\r\n",
        "a, b, c = temp\r\n",
        "print(a, b, c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "apple banana cake\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TQSWOO-q3KiX"
      },
      "source": [
        "#### 080 range 함수\r\n",
        "1 부터 99까지의 정수 중 짝수만 저장된 튜플을 생성하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "(2, 4, 6, 8 ... 98)\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0esMmYw64iK0",
        "outputId": "b0b68d2c-2a12-4104-f68d-9cc97f48272a"
      },
      "source": [
        "even = tuple(range(2, 100, 2))\r\n",
        "even"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2,\n",
              " 4,\n",
              " 6,\n",
              " 8,\n",
              " 10,\n",
              " 12,\n",
              " 14,\n",
              " 16,\n",
              " 18,\n",
              " 20,\n",
              " 22,\n",
              " 24,\n",
              " 26,\n",
              " 28,\n",
              " 30,\n",
              " 32,\n",
              " 34,\n",
              " 36,\n",
              " 38,\n",
              " 40,\n",
              " 42,\n",
              " 44,\n",
              " 46,\n",
              " 48,\n",
              " 50,\n",
              " 52,\n",
              " 54,\n",
              " 56,\n",
              " 58,\n",
              " 60,\n",
              " 62,\n",
              " 64,\n",
              " 66,\n",
              " 68,\n",
              " 70,\n",
              " 72,\n",
              " 74,\n",
              " 76,\n",
              " 78,\n",
              " 80,\n",
              " 82,\n",
              " 84,\n",
              " 86,\n",
              " 88,\n",
              " 90,\n",
              " 92,\n",
              " 94,\n",
              " 96,\n",
              " 98)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IOceQCTz3KlC"
      },
      "source": [
        "##06. 파이썬 딕셔너리\r\n",
        "----\r\n",
        "파이썬 딕셔너리는 순서는 없지만 key와 value 형태로 데이터를 저장합니다. 특히 key는 데이터의 레이블(label)을 지정하는 용도로 자주 사용됩니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GGk6jSIz3Km8"
      },
      "source": [
        "#### 081 별 표현식\r\n",
        "기본적으로 데이터 언패킹은 좌변의 변수와 우변 데이터 개수가 같아야 합니다. 하지만 star expression을 사용하면 변수의 개수가 달라도 데이터 언패킹을 할 수 있습니다. 튜플에 저장된 데이터 중에서 앞에 있는 두 개의 데이터만 필요할 경우 나머지 데이터의 언패킹 코드를 작성할 필요가 없습니다.\r\n",
        "\r\n",
        "```\r\n",
        ">> a, b, *c = (0, 1, 2, 3, 4, 5)\r\n",
        ">> a\r\n",
        "0\r\n",
        ">> b\r\n",
        "1\r\n",
        ">> c\r\n",
        "[2, 3, 4, 5]\r\n",
        "```\r\n",
        "\r\n",
        "다음과 같이 10개의 값이 저장된 scores 리스트가 있을 때, start expression을 사용하여 좌측 8개의 값을 valid_score 변수에 바인딩하여라.\r\n",
        "\r\n",
        "```\r\n",
        "scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_LFXldgV5gq0",
        "outputId": "f9de1293-eb75-401e-95d8-343c6b9b9c4e"
      },
      "source": [
        "scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\r\n",
        "*valid_score, _, _= scores\r\n",
        "print(valid_score)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TMhD09qr3KpD"
      },
      "source": [
        "#### 082\r\n",
        "다음과 같이 10개의 값이 저장된 scores 리스트가 있을 때, start expression을 사용하여 우측 8개의 값을 valid_score 변수에 바인딩하여라.\r\n",
        "\r\n",
        "```\r\n",
        "scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ngoesyh86HxJ",
        "outputId": "b32126d3-9432-49cc-b202-159e46bb607c"
      },
      "source": [
        "scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\r\n",
        "_, _, *valid_score= scores\r\n",
        "print(valid_score)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x35hD38e3Krj"
      },
      "source": [
        "#### 083\r\n",
        "다음과 같이 10개의 값이 저장된 scores 리스트가 있을 때, start expression을 사용하여 가운데 있는 8개의 값을 valid_score 변수에 바인딩하여라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uCOUN5XF6Xfs",
        "outputId": "4b949521-46d9-4748-bf55-afe5d3af4782"
      },
      "source": [
        "scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]\r\n",
        "_,*valid_score, _= scores\r\n",
        "print(valid_score)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5GNiQ3rq3Kty"
      },
      "source": [
        "####084 비어있는 딕셔너리\r\n",
        "temp 이름의 비어있는 딕셔너리를 만들라.\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iRnq5zuV6kO9"
      },
      "source": [
        "temp = { }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nCtA2Tx33Kv2"
      },
      "source": [
        "#### 085\r\n",
        "다음 아이스크림 이름과 희망 가격을 딕셔너리로 구성하라.\r\n",
        "\r\n",
        "\r\n",
        "|이름|희망가격|\r\n",
        "|------|---|\r\n",
        "|메로나|1000|\r\n",
        "|폴라포|1200|\r\n",
        "|빵빠레|1800|"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mJ_x43qhwdBz",
        "outputId": "61ff3405-58e4-46ff-a355-8da1c34c1ea1"
      },
      "source": [
        "icecream = {\"메로나\": 1000, \"폴라포\": 1200, \"빵빠레\": 1800}\r\n",
        "print(icecream)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'메로나': 1000, '폴라포': 1200, '빵빠레': 1800}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vNJWo6ta7IHr"
      },
      "source": [
        "#### 086\r\n",
        "085 번의 딕셔너리에 아래 아이스크림 가격정보를 추가하라.\r\n",
        "\r\n",
        "|이름|희망가격|\r\n",
        "|------|---|\r\n",
        "|죠스바|1200|\r\n",
        "|월드콘|1500|"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Bgrf9bF7Hr8",
        "outputId": "800b9707-86ae-415b-b0a7-1c5666466760"
      },
      "source": [
        "icecream = {\"메로나\": 1000, \"폴라포\": 1200, \"빵빠레\": 1800}\r\n",
        "icecream[\"죠스바\"] = 1200\r\n",
        "icecream[\"월드콘\"] = 1500\r\n",
        "icecream"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'메로나': 1000, '빵빠레': 1800, '월드콘': 1500, '죠스바': 1200, '폴라포': 1200}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "doHlNbMn7hUX"
      },
      "source": [
        "#### 087\r\n",
        "다음 딕셔너리를 사용하여 메로나 가격을 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "ice = {'메로나': 1000,\r\n",
        "       '폴로포': 1200,\r\n",
        "       '빵빠레': 1800,\r\n",
        "       '죠스바': 1200,\r\n",
        "       '월드콘': 1500}\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예:\r\n",
        "메로나 가격: 1000\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mWV_-1da7g9I",
        "outputId": "ed3573f1-d377-4f68-9a8b-954f39b401fc"
      },
      "source": [
        "ice = {'메로나': 1000,\r\n",
        "       '폴로포': 1200,\r\n",
        "       '빵빠레': 1800,\r\n",
        "       '죠스바': 1200,\r\n",
        "       '월드콘': 1500}\r\n",
        "\r\n",
        "print(\"메로나 가격: \", ice['메로나'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "메로나 가격:  1000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pRM9glSS7zPa"
      },
      "source": [
        "#### 088\r\n",
        "다음 딕셔너리에서 메로나의 가격을 1300으로 수정하라.\r\n",
        "\r\n",
        "```\r\n",
        "ice = {'메로나': 1000,\r\n",
        "       '폴로포': 1200,\r\n",
        "       '빵빠레': 1800,\r\n",
        "       '죠스바': 1200,\r\n",
        "       '월드콘': 1500}\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HvkJrC0_wdEH",
        "outputId": "c5e6db46-8459-4d85-910b-2f0a4ed914f2"
      },
      "source": [
        "ice = {'메로나': 1000,\r\n",
        "       '폴로포': 1200,\r\n",
        "       '빵빠레': 1800,\r\n",
        "       '죠스바': 1200,\r\n",
        "       '월드콘': 1500}\r\n",
        "\r\n",
        "ice[\"메로나\"] = 1300\r\n",
        "ice"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'메로나': 1300, '빵빠레': 1800, '월드콘': 1500, '죠스바': 1200, '폴로포': 1200}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fD_Bu_PL8F_X"
      },
      "source": [
        "#### 089\r\n",
        "다음 딕셔너리에서 메로나를 삭제하라.\r\n",
        "\r\n",
        "```\r\n",
        "ice = {'메로나': 1000,\r\n",
        "       '폴로포': 1200,\r\n",
        "       '빵빠레': 1800,\r\n",
        "       '죠스바': 1200,\r\n",
        "       '월드콘': 1500}\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VcH8m-jDwdF6",
        "outputId": "caf2947c-f08d-489e-ee7e-48bcd4d56073"
      },
      "source": [
        "del ice[\"메로나\"]\r\n",
        "ice"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'빵빠레': 1800, '월드콘': 1500, '죠스바': 1200, '폴로포': 1200}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mTdXeuP-8QM3"
      },
      "source": [
        "#### 090\r\n",
        "다음 코드에서 에러가 발생한 원인을 설명하라.\r\n",
        "\r\n",
        "```\r\n",
        ">> icecream = {'폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        ">> icecream['누가바']\r\n",
        "Traceback (most recent call last):\r\n",
        "  File \"<pyshell#69>\", line 1, in <module>\r\n",
        "    icecream['누가바']\r\n",
        "KeyError: '누가바'\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CiAl-cfN8Wz3"
      },
      "source": [
        "누가바가 딕셔너리 키에 없음."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dSN9-ZYw8eL5"
      },
      "source": [
        "#### 091 딕셔너리 생성\r\n",
        "아래의 표에서, 아이스크림 이름을 키값으로, (가격, 재고) 리스트를 딕셔너리의 값으로 저장하라. 딕셔너리의 이름은 inventory로 한다.\r\n",
        "\r\n",
        "\r\n",
        "|이름|가격|재고|\r\n",
        "|------|---|----|\r\n",
        "|메로나|300|100|\r\n",
        "|비비빅|400|3|\r\n",
        "|죠스바|250|100|"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VQtcf4XGwdMB",
        "outputId": "a1614da7-60f7-42f0-cf17-e6f9bfca1b0d"
      },
      "source": [
        "inventory = {\"메로나\": [300, 20], \r\n",
        "             \"비비빅\": [400, 3], \r\n",
        "             \"죠스바\": [250, 100]}\r\n",
        "print(inventory)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'메로나': [300, 20], '비비빅': [400, 3], '죠스바': [250, 100]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t-acMxhFwda9"
      },
      "source": [
        "#### 092 딕셔너리 인덱싱\r\n",
        "inventory 딕셔너리에서 메로나의 가격을 화면에 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "inventory = {\"메로나\": [300, 20],\r\n",
        "              \"비비빅\": [400, 3],\r\n",
        "              \"죠스바\": [250, 100]}\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시:\r\n",
        "300 원\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vC-oauawtUtY",
        "outputId": "60591133-71a6-4ce3-a77e-eaf89fc43b8f"
      },
      "source": [
        "inventory = {\"메로나\": [300, 20],\r\n",
        "              \"비비빅\": [400, 3],\r\n",
        "              \"죠스바\": [250, 100]}\r\n",
        "\r\n",
        "print(inventory[\"메로나\"][0], \"원\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "300 원\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M270439K9S4g"
      },
      "source": [
        "#### 093 딕셔너리 인덱싱\r\n",
        "inventory 딕셔너리에서 메로나의 재고를 화면에 출력하라.\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "inventory = {\"메로나\": [300, 20],\r\n",
        "              \"비비빅\": [400, 3],\r\n",
        "              \"죠스바\": [250, 100]}\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시:\r\n",
        "20 개\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mxJhFCPJ9AnU",
        "outputId": "1fc6cf19-0c1b-40b9-d605-00bf7fbcc2d3"
      },
      "source": [
        "inventory = {\"메로나\": [300, 20],\r\n",
        "              \"비비빅\": [400, 3],\r\n",
        "              \"죠스바\": [250, 100]}\r\n",
        "\r\n",
        "print(inventory[\"메로나\"][1], \"개\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20 개\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDi1NNxu9gUT"
      },
      "source": [
        "#### 094 딕셔너리 추가\r\n",
        "inventory 딕셔너리에 아래 데이터를 추가하라.\r\n",
        "\r\n",
        "```\r\n",
        "inventory = {\"메로나\": [300, 20],\r\n",
        "              \"비비빅\": [400, 3],\r\n",
        "              \"죠스바\": [250, 100]}\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n",
        "|이름|가격|재고|\r\n",
        "|------|---|----|\r\n",
        "|월드콘|500|7|\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시:\r\n",
        ">> print(inventory)\r\n",
        "{'메로나': [300, 20], '비비빅': [400, 3], '죠스바': [250, 100], '월드콘': [500, 7]}\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lhkVUe049c6U",
        "outputId": "5ef2f215-9ab7-4782-be4f-232ad4d2ac61"
      },
      "source": [
        "inventory = {\"메로나\": [300, 20],\r\n",
        "              \"비비빅\": [400, 3],\r\n",
        "              \"죠스바\": [250, 100]}\r\n",
        "\r\n",
        "inventory[\"월드콘\"] = [500, 7]\r\n",
        "\r\n",
        "print(inventory)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'메로나': [300, 20], '비비빅': [400, 3], '죠스바': [250, 100], '월드콘': [500, 7]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CxzmYvVo-Cka"
      },
      "source": [
        "#### 095 딕셔너리 keys() 메서드\r\n",
        "다음의 딕셔너리로부터 key 값으로만 구성된 리스트를 생성하라.\r\n",
        "\r\n",
        "```\r\n",
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "auVAREB_96qn",
        "outputId": "03483cd3-8070-4225-d1b4-16b4250adc67"
      },
      "source": [
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "icecream_keys = list(icecream.keys())\r\n",
        "icecream_keys"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['탱크보이', '폴라포', '빵빠레', '월드콘', '메로나']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PpIQlK1u-Qpa"
      },
      "source": [
        "#### 096 딕셔너리 values() 메서드\r\n",
        "다음의 딕셔너리에서 values 값으로만 구성된 리스트를 생성하라.\r\n",
        "\r\n",
        "```\r\n",
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "```\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d4k3Qrm--Py1",
        "outputId": "cd21029e-9f78-4d2b-dd93-a04794473572"
      },
      "source": [
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "price = list(icecream.values())\r\n",
        "print(price)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1200, 1200, 1800, 1500, 1000]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rjn-33S0-a4j"
      },
      "source": [
        "#### 097 딕셔너리 values() 메서드\r\n",
        "icecream 딕셔너리에서 아이스크림 판매 금액의 총합을 출력하라.\r\n",
        "\r\n",
        "```\r\n",
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "출력 예시:\r\n",
        "6700\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TnUZbiEa-ZB2",
        "outputId": "025fbe4d-2036-458b-dc15-b5eca9bc702e"
      },
      "source": [
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "print(sum(icecream.values()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6700\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uuuf9SWc_KcR"
      },
      "source": [
        "#### 098 딕셔너리 update 메서드\r\n",
        "아래의 new_product 딕셔너리를 다음 icecream 딕셔너리에 추가하라.\r\n",
        "\r\n",
        "```\r\n",
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "new_product = {'팥빙수':2700, '아맛나':1000}\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시:\r\n",
        ">> print(icecream)\r\n",
        "{'탱크보이': 1200,  '폴라포': 1200,  '빵빠레': 1800,  '월드콘': 1500,  '메로나': 1000,  '팥빙수':2700, '아맛나':1000}\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7A7AHLP__KHC",
        "outputId": "89a2d05b-e4b0-454c-a313-ae38a5c15b5f"
      },
      "source": [
        "icecream = {'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000}\r\n",
        "new_product = {'팥빙수':2700, '아맛나':1000}\r\n",
        "icecream.update(new_product)\r\n",
        "print(icecream)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'탱크보이': 1200, '폴라포': 1200, '빵빠레': 1800, '월드콘': 1500, '메로나': 1000, '팥빙수': 2700, '아맛나': 1000}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FjDm7yK5_WhF"
      },
      "source": [
        "#### 099 zip과 dict\r\n",
        "아래 두 개의 튜플을 하나의 딕셔너리로 변환하라. keys를 키로, vals를 값으로 result 이름의 딕셔너리로 저장한다.\r\n",
        "\r\n",
        "```\r\n",
        "keys = (\"apple\", \"pear\", \"peach\")\r\n",
        "vals = (300, 250, 400)\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시:\r\n",
        ">> print(result)\r\n",
        "{'apple': 300, 'pear': 250, 'peach': 400}\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xT6v9eyK-i8q",
        "outputId": "148bac7b-32ab-4c2d-b73d-7a0f3666f661"
      },
      "source": [
        "keys = (\"apple\", \"pear\", \"peach\")\r\n",
        "vals = (300, 250, 400)\r\n",
        "result = dict(zip(keys, vals))\r\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'apple': 300, 'pear': 250, 'peach': 400}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HXphGYeY_nOt"
      },
      "source": [
        "#### 100 zip과 dict\r\n",
        "date와 close_price 두 개의 리스트를 close_table 이름의 딕셔너리로 생성하라.\r\n",
        "\r\n",
        "```\r\n",
        "date = ['09/05', '09/06', '09/07', '09/08', '09/09']\r\n",
        "close_price = [10500, 10300, 10100, 10800, 11000]\r\n",
        "```\r\n",
        "\r\n",
        "```\r\n",
        "실행 예시:\r\n",
        ">> print(close_table)\r\n",
        "{'09/05': 10500, '09/06': 10300, '09/07': 10100, '09/08': 10800, '09/09': 11000}\r\n",
        "```\r\n",
        "\r\n",
        "\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c1jGcEDQ_G2l",
        "outputId": "04c5d399-b1c0-40df-fb63-d436da7b3f13"
      },
      "source": [
        "date = ['09/05', '09/06', '09/07', '09/08', '09/09']\r\n",
        "close_price = [10500, 10300, 10100, 10800, 11000]\r\n",
        "close_table = dict(zip(date, close_price))\r\n",
        "print(close_table)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'09/05': 10500, '09/06': 10300, '09/07': 10100, '09/08': 10800, '09/09': 11000}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ejhCeW4n_3Jt"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}