Chapter07.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Chapter07.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPiMgoqCJZFQrGoCj02jLfL",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/HelloJinny/python-for-beginner/blob/master/Chapter07.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F4o2mw0IEjW4"
      },
      "source": [
        "# 1. 리스트"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AxG1ye5n6-Uo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35f79718-b0f1-46d5-9ecb-510afd387b42"
      },
      "source": [
        "# Code 07-03\n",
        "aa = []\n",
        "\n",
        "for i in range(0, 4):\n",
        "    aa.append(0)\n",
        "hap = 0\n",
        "\n",
        "for i in range(0, 4):\n",
        "    aa[i] = int(input(str(i + 1) + \"번째 숫자 : \"))\n",
        "\n",
        "for i in range(0, 4):\n",
        "    hap = hap + aa[i]\n",
        "\n",
        "print(\"합계 ==> %d\" % hap)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1번째 숫자 : 10\n",
            "2번째 숫자 : 20\n",
            "3번째 숫자 : 30\n",
            "4번째 숫자 : 40\n",
            "합계 ==> 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TxH1V8Z67V5S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a5c3dc3-1507-46f3-c63e-ad5308b5a418"
      },
      "source": [
        "409## SELF STUDY 7-1\n",
        "# 값을 4개가 아닌 10개를 입력받아 합계를 출력\n",
        "# 합계를 구하는 마지막 for 문 대신 while 문을 사용\n",
        "aa = []\n",
        "\n",
        "for i in range(0, 10):\n",
        "    aa.append(0)\n",
        "hap = 0\n",
        "\n",
        "for i in range(0, 10):\n",
        "    aa[i] = int(input(str(i + 1) + \"번째 숫자 : \"))\n",
        "\n",
        "i = 0\n",
        "while (i < 10):\n",
        "    hap = hap + aa[i]\n",
        "    i += 1\n",
        "\n",
        "print(\"합계 ==> %d\" % hap)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1번째 숫자 : 1\n",
            "2번째 숫자 : 2\n",
            "3번째 숫자 : 3\n",
            "4번째 숫자 : 4\n",
            "5번째 숫자 : 5\n",
            "6번째 숫자 : 6\n",
            "7번째 숫자 : 7\n",
            "8번째 숫자 : 8\n",
            "9번째 숫자 : 9\n",
            "10번째 숫자 : 10\n",
            "합계 ==> 55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJhCnrzZ7fHB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4be29c4d-1ea6-4cd6-b26c-deb1b2b43015"
      },
      "source": [
        "# Code 07-04\n",
        "aa = []\n",
        "bb = []\n",
        "value = 0\n",
        "\n",
        "for i in range(0, 100):\n",
        "    aa.append(value)\n",
        "    value += 2\n",
        "\n",
        "for i in range(0, 100):\n",
        "    bb.append(aa[99 - i])\n",
        "\n",
        "print(\"bb[0]에는 %d이, bb[99]에는 %d이 입력됩니다.\" % (bb[0], bb[99]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "bb[0]에는 198이, bb[99]에는 0이 입력됩니다.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f_j_z5OI8Nvy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "204848dd-6065-491a-da30-256c00bca03e"
      },
      "source": [
        "## SELF STUDY 7-2\n",
        "# 리스트 aa에 3의 배수 200개를 입력\n",
        "# 리스트 bb에 리스트 aa의 역순으로 입력\n",
        "# bb[0]과 b[199]의 값을 출력\n",
        "aa = []\n",
        "bb = []\n",
        "value = 0\n",
        "\n",
        "for i in range(0,200) :\n",
        "    aa.append(value)\n",
        "    value += 3\n",
        "\n",
        "for i in range(0, 200) :\n",
        "    bb.append(aa[199-i])\n",
        "\n",
        "print(\" bb[0]에는 %d이, bb[199]에는 %d이 입력됩니다.\" %(bb[0], bb[199] ))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " bb[0]에는 597이, bb[199]에는 0이 입력됩니다.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eQHqNK1fAxkp"
      },
      "source": [
        "## 리스트 조작 함수"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8T7Vsze9uUX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "319bdc5b-34bf-4902-a162-363af86760bf"
      },
      "source": [
        "# Code07-05\n",
        "myList = [30, 10, 20]\n",
        "print(\"현재 리스트 : %s\" % myList)\n",
        "\n",
        "myList.append(40)\n",
        "print(\"append(40) 후의 리스트 : %s\" % myList)\n",
        "\n",
        "print(\"pop()으로 추출한 값 : %s\" % myList.pop())\n",
        "print(\"pop() 후의 리스트 : %s\" % myList)\n",
        "\n",
        "myList.sort()\n",
        "print(\"sort() 후의 리스트 : %s\" % myList)\n",
        "\n",
        "myList.reverse()\n",
        "print(\"reverse() 후의 리스트 : %s\" % myList)\n",
        "\n",
        "print(\"20값의 위치 : %d\" % myList.index(20))\n",
        "\n",
        "myList.insert(2, 222)\n",
        "print(\"insert(2, 222) 후의 리스트 : %s\" % myList)\n",
        "\n",
        "myList.remove(222)\n",
        "print(\"remove(222) 후의 리스트 : %s\" % myList)\n",
        "\n",
        "myList.extend( [77, 88, 77] )\n",
        "print(\"extend([77, 88, 77]) 후의 리스트 : %s\" % myList)\n",
        "\n",
        "print(\"77값의 개수 : %d\" % myList.count(77))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "현재 리스트 : [30, 10, 20]\n",
            "append(40) 후의 리스트 : [30, 10, 20, 40]\n",
            "pop()으로 추출한 값 : 40\n",
            "pop() 후의 리스트 : [30, 10, 20]\n",
            "sort() 후의 리스트 : [10, 20, 30]\n",
            "reverse() 후의 리스트 : [30, 20, 10]\n",
            "20값의 위치 : 1\n",
            "insert(2, 222) 후의 리스트 : [30, 20, 222, 10]\n",
            "remove(222) 후의 리스트 : [30, 20, 10]\n",
            "extend([77, 88, 77]) 후의 리스트 : [30, 20, 10, 77, 88, 77]\n",
            "77값의 개수 : 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n3eTWyLG-mWv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8064d2d9-047a-406a-a92a-0691b251b3b2"
      },
      "source": [
        "myList = [30, 10, 20]\n",
        "newList = sorted(myList) # 리스트는 그대로 두고 정렬된 결과만 반환\n",
        "print(\"sorted() 후의 myList : %s\" % myList)\n",
        "print(\"sorted() 후의 newList : %s\" % newList)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sorted() 후의 myList : [30, 10, 20]\n",
            "sorted() 후의 newList : [10, 20, 30]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9BQZAkyNEiKK"
      },
      "source": [
        "## 2차원 리스트"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pd-FEohu8mUi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "904ada22-9b91-470e-80cc-355e27e2ebc5"
      },
      "source": [
        "# Code07-06\n",
        "list1 = []\n",
        "list2 = []\n",
        "value=1\n",
        "for i in range(0, 3) : # 행 ↓\n",
        "    for k in range(0, 4) : # 열 →\n",
        "        list1.append(value)\n",
        "        value += 1\n",
        "    list2.append(list1)\n",
        "    list1 = []\n",
        "\n",
        "for i in range(0, 3) :\n",
        "    for k in range(0, 4) :\n",
        "        print(\"%3d\" % list2[i][k], end = \" \")\n",
        "    print(\"\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  1   2   3   4 \n",
            "  5   6   7   8 \n",
            "  9  10  11  12 \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "diktMLI-8aIB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "118bcbd4-e9b4-46c7-ec2f-e022dab747ce"
      },
      "source": [
        "# SELF STUDY 7-3\n",
        "# 4행 5열의 2차원 리스트를 만들고,\n",
        "# 0부터 3의 배수를 입력하고 출력\n",
        "list1 = [ ]\n",
        "list2 = [ ]\n",
        "value=0\n",
        "for i in range(0, 4) :\n",
        "    for k in range(0, 5) :\n",
        "        list1.append(value)\n",
        "        value += 3\n",
        "    list2.append(list1)\n",
        "    list1 = []\n",
        "\n",
        "for i in range(0, 4) :\n",
        "    for k in range(0, 5) :\n",
        "        print(\"%3d\" % list2[i][k], end=\" \")\n",
        "    print(\"\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  0   3   6   9  12 \n",
            " 15  18  21  24  27 \n",
            " 30  33  36  39  42 \n",
            " 45  48  51  54  57 \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2H7wOcyfErR4"
      },
      "source": [
        "# 2. 튜플"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qr2N3Dx48aPX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0b403f43-3e1f-402c-f0bb-96ab0139087a"
      },
      "source": [
        "# SELF STUDY 7-4\n",
        "# 2차원 튜플을 생성한 후 모든 값을 출력\n",
        "# tt = ((1, 2, 3), (4, 5, 6), (7, 8, 9))\n",
        "tt = ((1, 2, 3),\n",
        "      (4, 5, 6),\n",
        "      (7, 8, 9))\n",
        "\n",
        "for i in range(0, 3) :\n",
        "    for k in range(0, 3) :\n",
        "        print(\"%3d\" %tt[i][k], end=\" \")\n",
        "    print(\"\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  1   2   3 \n",
            "  4   5   6 \n",
            "  7   8   9 \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T72hLzvt8aUQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2772b852-58d3-47b2-97e6-dad618be88f1"
      },
      "source": [
        "# 튜플과 리스트는 서로 변환할 수 있다.\n",
        "# 튜플 → 리스트 → 튜플\n",
        "myTuple = (10, 20, 30)\n",
        "myList = list(myTuple)\n",
        "myList.append(40)\n",
        "myTuple = tuple(myList)\n",
        "print(myTuple)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(10, 20, 30, 40)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nY05uyMyErYh"
      },
      "source": [
        "# 3. 딕셔너리"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nRfx-AXb8aXg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82f13f2e-83de-4ffe-8a5a-6deb722a96c7"
      },
      "source": [
        "student1 = {'학번' : 1000, '이름' : '홍길동', '학과' : '컴퓨터학과'}\n",
        "print(student1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'학번': 1000, '이름': '홍길동', '학과': '컴퓨터학과'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwIEJfLP8aaQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1695772-2aa5-40fb-a4c5-30d0a5ec0fc4"
      },
      "source": [
        "# 연락처 추가\n",
        "student1['연락처'] = '010-1111-2222'\n",
        "print(student1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'학번': 1000, '이름': '홍길동', '학과': '컴퓨터학과', '연락처': '010-1111-2222'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AfnvuN5BJtkj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1fed482a-0147-4569-fef4-a1eb701cfe30"
      },
      "source": [
        "# 이미 존재하는 키를 사용하면 새로운 쌍이 추가되는 것이 아니라 기존값이 변경 (키는 유일해야 한다.)\n",
        "student1['학과'] = '파이썬학과'\n",
        "print(student1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'학번': 1000, '이름': '홍길동', '학과': '파이썬학과', '연락처': '010-1111-2222'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0y63PvOXJtnK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5a4e9e05-bf42-4ddb-d311-5736696af7e1"
      },
      "source": [
        "# 딕셔너리 쌍 삭제 del(딕셔너리명[키])\n",
        "del(student1['학과'])\n",
        "print(student1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'학번': 1000, '이름': '홍길동', '연락처': '010-1111-2222'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nijG-XqoJtp8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33bb04a0-ecd5-4579-86b0-f9719b47cb25"
      },
      "source": [
        "# 동일한 키를 갖는 딕셔너리를 생성하지 않고 마지막에 있는 키가 적용 (키는 유일해야 한다.)\n",
        "student1 = {'학번' : 1000, '이름' : '홍길동', '학과' : '파이썬학과', '학번' : 2000}\n",
        "print(student1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'학번': 2000, '이름': '홍길동', '학과': '파이썬학과'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M7TN7AjLKo-E"
      },
      "source": [
        "### 딕셔너리 사용"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cUY3H0fyJtsU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "850f0dee-cd72-4e08-927e-32207260e0ca"
      },
      "source": [
        "print(student1['학번'])\n",
        "print(student1['이름'])\n",
        "print(student1['학과'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2000\n",
            "홍길동\n",
            "파이썬학과\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E2U4HQg3JtvL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6c79380f-e317-4a55-f83c-8375190b5a76"
      },
      "source": [
        "# 딕셔너리명.get(키) : 키로 값에 접근, \n",
        "student1.get('이름')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'홍길동'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VJn3Bf-KJtyM"
      },
      "source": [
        "# 딕셔너리[키] : 없는 키를 호출하면 오류\n",
        "# 딕셔너리명.get(키) : 없는 키를 호출하면 아무것도 반환하지 않는다.\n",
        "student1.['주소']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5kKS-YL0Jt1M"
      },
      "source": [
        "student1.get('주소')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1aUeJ1BpLfC8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b11f806d-102a-498b-8d09-d93d8583acfa"
      },
      "source": [
        "# 딕셔너리명.keys() : 딕셔너리의 모든 키를 반환\n",
        "student1.keys()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['학번', '이름', '학과'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N7NuMdc7LfFb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9248112f-db2e-46e8-bc95-dff4aec5c689"
      },
      "source": [
        "# dict_keys가 보기 싫으면 list(딕셔너리명.keys())\n",
        "list(student1.keys())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['학번', '이름', '학과']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L0UY7CDTLfIT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "479cb063-c9fe-44aa-f6d0-c18f4783def2"
      },
      "source": [
        "# 딕셔너리명.values() : 딕셔너리의 모든 값을 리스트로 만들어 반환\n",
        "# dict_keys가 보기 싫으면 list(딕셔너리명.values())\n",
        "student1.values()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_values([2000, '홍길동', '파이썬학과'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GBuSkMVPLfKt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4f5f1633-687c-4d47-c1a5-e667cae39bdc"
      },
      "source": [
        "# 딕셔너리명.items() : 튜플 형태로 구할 수 있다.\n",
        "student1.items()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('학번', 2000), ('이름', '홍길동'), ('학과', '파이썬학과')])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "88xdRb5FNRyk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "415d5788-7bd1-4768-ea53-dc875a37bb33"
      },
      "source": [
        "# 딕셔너리 안에 해당 키가 있는지 없는지 in을 사용해 확인\n",
        "print('이름' in student1)\n",
        "print('주소' in student1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6zMn-uUyNR4C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec4a4900-836b-476d-de73-fe3a18043460"
      },
      "source": [
        "# Code 07-08\n",
        "singer = {}\n",
        "\n",
        "singer['이름'] = '트와이스'\n",
        "singer['구성원수'] = 9\n",
        "singer['데뷰'] = '서바이벌 식스틴'\n",
        "singer['대표곡'] = 'SIGNAL'\n",
        "\n",
        "for k in singer.keys() :\n",
        "    print('%s --> %s' % (k, singer[k]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "이름 --> 트와이스\n",
            "구성원수 --> 9\n",
            "데뷰 --> 서바이벌 식스틴\n",
            "대표곡 --> SIGNAL\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lQW1QP_POsrI"
      },
      "source": [
        "### 딕셔너리의 정렬"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I0N5EeR4NR6j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "47e61b50-edcb-43bd-afdd-7619d6650fd4"
      },
      "source": [
        "# Code 07-09\n",
        "# 각 결과는 튜플로 변경되며 리스트로 반환된다.\n",
        "import operator\n",
        "\n",
        "trainDic, trainList = {}, []\n",
        "\n",
        "trainDic = {'Thomas':'토마스', 'Edward':'에드워드', 'Henry':'헨리', 'Gothen':'고든', 'James':'제임스'}\n",
        "trainList = sorted(trainDic.items(), key=operator.itemgetter(0))\n",
        "\n",
        "print(trainList)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[('Edward', '에드워드'), ('Gothen', '고든'), ('Henry', '헨리'), ('James', '제임스'), ('Thomas', '토마스')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G9EvzIPGNR9S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b102c04-f339-4eef-a935-5564090b1f41"
      },
      "source": [
        "# Code 07-10\n",
        "## 변수 선언 부분 ##\n",
        "foods = {\"떡볶이\" : \"오뎅\", \n",
        "         \"짜장면\" : \"단무지\",\n",
        "         \"라면\"   : \"김치\",\n",
        "         \"피자\"   : \"피클\",\n",
        "         \"맥주\"   : \"땅콩\",\n",
        "         \"치킨\"   : \"치킨무\",\n",
        "         \"삼겹살\" : \"상추\" };\n",
        "\n",
        "## 메인 코드 부분 ##\n",
        "while (True) :\n",
        "    myfood = input(str(list(foods.keys())) + \" 중 좋아하는 음식은?\")\n",
        "    if myfood in foods :\n",
        "        print(\"<%s> 궁합 음식은 <%s>입니다.\" % (myfood, foods.get(myfood)))\n",
        "    elif myfood == \"끝\" :\n",
        "        break\n",
        "    else :\n",
        "        print(\"그런 음식이 없습니다. 확인해 보세요.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['떡볶이', '짜장면', '라면', '피자', '맥주', '치킨', '삼겹살'] 중 좋아하는 음식은?삼겹살\n",
            "<삼겹살> 궁합 음식은 <상추>입니다.\n",
            "['떡볶이', '짜장면', '라면', '피자', '맥주', '치킨', '삼겹살'] 중 좋아하는 음식은?끝\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XAviozfYNR_t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26fbde26-1e59-4025-a59b-42ada8f30a2b"
      },
      "source": [
        "# SELF-STUDY 7-5\n",
        "# Code 07-10 수정해 동물의 어미와 새끼의 이름을 딕셔너리로 묶는 프로그램을 작성\n",
        "## 변수 선언 부분 ## \n",
        "animals = { \"개\" : \"강아지\", \n",
        "              \"호랑이\" : \"개호주\",\n",
        "              \"곰\" : \"능소니\",\n",
        "              \"말\" : \"망아지\",\n",
        "              \"닭\" : \"병아리\",\n",
        "              \"고등어\" : \"고도리\",\n",
        "              \"명태\" : \"노가리\" };\n",
        "\n",
        "## 메인 코드 부분 ## \n",
        "while (True) :\n",
        "    myPet = input( str(list(animals.keys())) + \" 중 새끼 이름을 알고 싶은 동물은? \" )\n",
        "    if myPet in animals :\n",
        "        print(\"<%s>의 새끼는 <%s>입니다.\" %(myPet, animals.get(myPet)))\n",
        "    elif myPet == \"끝\" :\n",
        "        break\n",
        "    else :\n",
        "        print(\"그런 동물이 없습니다. 확인해 보세요. \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['개', '호랑이', '곰', '말', '닭', '고등어', '명태'] 중 새끼 이름을 알고 싶은 동물은? 호랑이\n",
            "<호랑이>의 새끼는 <개호주>입니다.\n",
            "['개', '호랑이', '곰', '말', '닭', '고등어', '명태'] 중 새끼 이름을 알고 싶은 동물은? 끝\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H5-Ft_utW7C8"
      },
      "source": [
        "# 4. 리스트, 튜플, 딕셔너리의 심화 내용"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K34HmlOXXEn7"
      },
      "source": [
        "### 세트 (Set)\n",
        "- 키만 모아 놓은 딕셔너리의 특수한 형태\n",
        "- 딕셔너리의 키는 중복되면 안 되므로 세트에 들어 있는 값은 항상 유일하다.\n",
        "- 세트를 생성하려면 딕셔너리처럼 중괄호 {}를사용하지만 : 없이 값을 입력한다.\n",
        "- 리스트, 튜플, 딕셔너리 등을 세트로 변경시켜 준다.\n",
        "- 딕셔너리와 마찬가지로 별도의 순서로 지정되지 않는다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sTfOc5PANSCj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b1d3777c-2342-4a16-fa46-5904532b6eed"
      },
      "source": [
        "mySet1 = {1, 2, 3, 3, 3, 4}\n",
        "print(mySet1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{1, 2, 3, 4}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "65YTqhnSXDRD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9f10579-6e45-4ea7-fcd2-c865a8a5bb21"
      },
      "source": [
        "saleList = ['삼각김밥', '바나나', '도시락', '삼각김밥', '삼각김밥', '도시락', '삼각김밥']\n",
        "print(set(saleList))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'바나나', '삼각김밥', '도시락'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "te1v8TgFXDUC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f76580b3-e72a-4347-c165-8fd2dd7f9533"
      },
      "source": [
        "mySet1 = {1, 2, 3, 4, 5}\n",
        "mySet2 = {4, 5, 6, 7}\n",
        "\n",
        "print(mySet1 & mySet2) # 교집합\n",
        "print(mySet1 | mySet2) # 합집합\n",
        "print(mySet1 - mySet2) # 차집합\n",
        "print(mySet1 ^ mySet2) # 대칭 차집합"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{4, 5}\n",
            "{1, 2, 3, 4, 5, 6, 7}\n",
            "{1, 2, 3}\n",
            "{1, 2, 3, 6, 7}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3u9szcmvXDXE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "54c193d5-dd01-4bd1-f01d-d2eb0f6613dc"
      },
      "source": [
        "print(mySet1.intersection(mySet2)) # 교집합\n",
        "print(mySet1.union(mySet2)) # 합집합\n",
        "print(mySet1.difference(mySet2)) # 차집합\n",
        "print(mySet1.symmetric_difference(mySet2)) # 대칭 차집합"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{4, 5}\n",
            "{1, 2, 3, 4, 5, 6, 7}\n",
            "{1, 2, 3}\n",
            "{1, 2, 3, 6, 7}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dls2vM4saAPM"
      },
      "source": [
        "### 컴프리헨션 (Comprehension : 함축)\n",
        "- 값이 순차적인 리스트를 한 줄로 만드는 간단한 방법\n",
        "- 리스트 = [수식 for 항목 in range() if 조건식]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bOvgVZdZXDZx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5a5a10ef-12eb-4907-a76f-21ab80169bcd"
      },
      "source": [
        "# numList = []\n",
        "# for num in range(1, 6):\n",
        "#     numList.append(num,)\n",
        "# numList\n",
        "\n",
        "numList = [num for num in range(1, 6)]\n",
        "numList"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wdcBSk_jaHcj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c403796d-9cd8-484d-b49f-622255e829b7"
      },
      "source": [
        "# 1~5의 제곱으로 구성된 리스트\n",
        "numList = [num * num for num in range(1, 6)]\n",
        "numList"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 4, 9, 16, 25]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MwAIm-gYaHe7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e9d03dbc-e35f-43ff-dd3f-1d1a38fa5456"
      },
      "source": [
        "# 1~20 숫자 중에서 3의 배수로만 리스트를 구성하는 방법\n",
        "numList = [num for num in range(1, 21) if num % 3 == 0]\n",
        "numList"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 6, 9, 12, 15, 18]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0tHnUlcTbkBi"
      },
      "source": [
        "### 동시에 여러 리스트에 접근 : zip() 함수 이용"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Fw910ZjaHiP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6aac5faa-9148-45ee-cbf5-99a3ba0316b5"
      },
      "source": [
        "foods = ['떡볶이', '짜장면', '라면', '피자', '맥주', '치킨', '삼겹살']\n",
        "sides = ['오뎅', '단무지', '김치']\n",
        "for food, side in zip(foods, sides):\n",
        "    print(food, ' --> ', side)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "떡볶이  -->  오뎅\n",
            "짜장면  -->  단무지\n",
            "라면  -->  김치\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WUZd02JJbrCu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1ed957b-6e6c-4dda-8e18-a1a85e56922d"
      },
      "source": [
        "foods = ['떡볶이', '짜장면', '라면', '피자', '맥주', '치킨', '삼겹살']\n",
        "sides = ['오뎅', '단무지', '김치']\n",
        "tupList = list(zip(foods, sides))\n",
        "dic = dict(zip(foods, sides))\n",
        "print(tupList)\n",
        "print(dic)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[('떡볶이', '오뎅'), ('짜장면', '단무지'), ('라면', '김치')]\n",
            "{'떡볶이': '오뎅', '짜장면': '단무지', '라면': '김치'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tHMQeF01bo6A"
      },
      "source": [
        "### 리스트의 복사"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "97l_fU0EaHkL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb25a6a2-cd0e-4122-bcd3-b3de9a0526e5"
      },
      "source": [
        "# 얕은 복사\n",
        "oldList = ['짜장면', '탕수육', '군만두']\n",
        "newList = oldList\n",
        "print(newList)\n",
        "\n",
        "oldList[0] = '짬뽕'\n",
        "oldList.append('깐풍기')\n",
        "print(newList)\n",
        "print(oldList)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['짜장면', '탕수육', '군만두']\n",
            "['짬뽕', '탕수육', '군만두', '깐풍기']\n",
            "['짬뽕', '탕수육', '군만두', '깐풍기']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uq3t05NAaHm8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a530161f-8bfe-4e9c-923c-dcb1a1f6be48"
      },
      "source": [
        "# 깊은 복사\n",
        "oldList = ['짜장면', '탕수육', '군만두']\n",
        "newList = oldList[:] # 메모리 공간을 복사해서 새로 만든다 : 깊은 복사# 깊은 복사\n",
        "print(newList)\n",
        "\n",
        "oldList[0] = '짬뽕'\n",
        "oldList.append('깐풍기')\n",
        "print(newList)\n",
        "print(oldList)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['짜장면', '탕수육', '군만두']\n",
            "['짜장면', '탕수육', '군만두']\n",
            "['짬뽕', '탕수육', '군만두', '깐풍기']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K0pxp7z8cVTN"
      },
      "source": [
        "### 리스트를 이용한 스택 구현\n",
        "\n",
        "스택 (stack) : 한 쪽 끝이 막혀 먼저 들어간 것이 가장 나중에 나오는 형태의 자료구조"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8XIdP23fvX6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5608ce03-589f-4e14-8c07-bcee8a23d4f9"
      },
      "source": [
        "parking = []\n",
        "top = 0\n",
        "\n",
        "parking.append('자동차A') # A\n",
        "top += 1\n",
        "\n",
        "parking.append('자동차B') # A B\n",
        "top += 1\n",
        "\n",
        "parking.append('자동차C') # A B C\n",
        "top += 1\n",
        "\n",
        "top -= 1\n",
        "outCar = parking.pop()\n",
        "print(outCar)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "자동차C\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}