02_python01.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "02_python01.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "interpreter": {
      "hash": "b3ba2566441a7c06988d0923437866b63cedc61552a5af99d1f4fb67d367b25f"
    },
    "kernelspec": {
      "display_name": "Python 3.8.5 64-bit ('base': conda)",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": ""
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cybermin/2021_PNUAC_AIData/blob/main/02_python01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "su17VGVlJM1g"
      },
      "source": [
        "# 파이썬 기초\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sv3CQZ0OTYEQ"
      },
      "source": [
        "## 파이썬\n",
        "* 1990년 암스테르담의 귀도 반 로섬(Guido Van Rossum)이 개발한 **플랫폼 독립**적인 **인터프리터** 언어 \n",
        "  + 변수를 선언할 때 타입을 지정하지 않음\n",
        "  + 값을 할당하면 그때 동적으로 타입이 정해짐\n",
        "  + 타입이 다를 경우 형 변환을 해줘야 연산에 사용할 수 있음\n",
        "  \n",
        "### 파이썬 기본 문법\n",
        "* 주석 : 프로그램 실행과 관계 없이 코드에 대한 설명을 작성\n",
        "  + 한줄 주석 : # \n",
        "  + 여러줄 주석 : 작은따옴표 세개('''주석내용''')\n",
        "\n",
        "* 들여쓰기(indent)\n",
        "  + 코드 블럭을 구성하기 위해서는 반드시 들여쓰기 해야함\n",
        "\n",
        "* 행분리 : 역슬래쉬(\\)\n",
        "  + 하나의 명령을 여러 줄에 수행\n",
        "\n",
        "* 행결합 : 세미콜론(;)\n",
        "  + 한 줄에 여러 명령 수행\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z19VF2KQTC6u",
        "outputId": "b872194f-9e26-4335-d337-7f52e6f33c5b"
      },
      "source": [
        "'''\n",
        "작성자 : 김경민\n",
        "'''\n",
        "\n",
        "print('Hello Python!') #첫번째 출력코드\n",
        "\n",
        "# 행분리\n",
        "print('Hello \\\n",
        "Python!')\n",
        "\n",
        "# 행결합\n",
        "print('Hello', end=' '); print('Python!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello Python!\n",
            "Hello Python!\n",
            "Hello Python!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UK8mIocaHcm6"
      },
      "source": [
        "## 변수(Variable)\n",
        "* 필요한 데이터를 저장해 놓는 기억 공간의 별칭\n",
        "* 변수 명 규칙\n",
        "  + 영문 문자와 숫자 사용 : 대소문자 구분\n",
        "  + 문자나 _(밑줄 문자)로 시작 : 숫자부터 시작하면 안 됨\n",
        "  + 특수 문자(+, -, *, /, $, @, &, % 등)는 사용할 수 없음\n",
        "  + python 키워드(if, for, while, and, or 등)는 사용할 수 없음\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KbXsZqOQC9C4"
      },
      "source": [
        "\n",
        "### 파이썬 데이터 타입(Data Type)\n",
        "* 정수 : 정수 자료형(int)\n",
        "* 실수 : 부동소수점 자료형(float)\n",
        "* 참거짓 : 참(True)과 거짓(False)를 나타내는 부울 자료형(bool)\n",
        "* 문자열 : 문자열 자료형(str), 작은따옴표('')나 큰따옴표(\"\")로 묶음\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6N1gGIhVC-__"
      },
      "source": [
        "\n",
        "### 데이터 타입 확인 \n",
        "* type() 함수 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R4zETtllGaBS",
        "outputId": "65849d3f-ef67-4d27-fe53-abf4325adea4"
      },
      "source": [
        "x = 10\n",
        "y = 20.5\n",
        "b = True \n",
        "s = 'Hello Python!'\n",
        "\n",
        "print(x, '=>', type(x))\n",
        "print(y, '=>', type(y))\n",
        "print(b, '=>', type(b)) \n",
        "print(s, '=>', type(s))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10 => <class 'int'>\n",
            "20.5 => <class 'float'>\n",
            "True => <class 'bool'>\n",
            "C => <class 'str'>\n",
            "Hello Python! => <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "11wNQjyDPh-w"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "**생각해보기)**\n",
        "\n",
        "\n",
        "---\n",
        "10과 '10'은 같은 자료형일까?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwtNjm3wXfLq"
      },
      "source": [
        "## 형변환(type Casting)\n",
        "* int() : 실수나 문자열을 정수로 변환\n",
        "* float() : 정수나 문자열을 실수로 변환\n",
        "* str() : 정수나 실수를 문자열로 변환"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ckeWLeSwa4KL",
        "outputId": "62d6f569-826f-469e-ef99-2c76dd8f6052"
      },
      "source": [
        "x = '10'\n",
        "y = int(x)\n",
        "\n",
        "print(x, '=>', type(x))\n",
        "print(y, '=>', type(y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10 => <class 'str'>\n",
            "10 => <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DWtUMslKJsti"
      },
      "source": [
        "## 파이썬 기본 입출력\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Bzget_gCrTY"
      },
      "source": [
        "### 표준 입력 : input() \n",
        "* 표준 입력 장치인 키보드로 부터 입력\n",
        "* 입력된 값은 문자열\n",
        "```python\n",
        "input() # 표준 입력장치로 부터 문자열을 입력\n",
        "input('문자열') # 문자열을 출력하고 표준 입력장치로 부터 문자열 입력\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xQJnx1BGOV6s",
        "outputId": "b5fd0362-16c7-413a-bf1b-43a4130f40dd"
      },
      "source": [
        "x = input()\n",
        "print(x, '=>', type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "10 => <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zxsjrnPrbL41"
      },
      "source": [
        "---\n",
        "\n",
        "**생각해보기)**\n",
        "\n",
        "\n",
        "---\n",
        "정수나 실수 입력은 어떻게 받을까?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkIw8ddZbV64"
      },
      "source": [
        "### 숫자 입력 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pxD3xR4_7lww",
        "outputId": "859e9760-8a2f-42f2-8330-8840a1356e41"
      },
      "source": [
        "#정수 입력\n",
        " \n",
        "\n",
        "#실수 입력\n",
        " \n",
        "\n",
        "print(x, '=>', type(x))\n",
        "print(y, '=>', type(y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "10\n",
            "10 => <class 'int'>\n",
            "10.0 => <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_mn6EKvJOVhJ"
      },
      "source": [
        "\n",
        "### 표준 출력 : print() \n",
        "* 표준 출력 장치인 모니터로 출력\n",
        "```python\n",
        "print(값1, 값2, ....) # 문자열을 출력하고 표준 입력장치로 부터 문자열 입력\n",
        "```\n",
        "\n",
        "* f-string\n",
        "  + Python 신규 버전(3.6 이상) 부터 제공되는 기능\n",
        "  + f'문자열' : f로 시작하는 문자열\n",
        "    + 문자열 내부에 변수의 내용을 사용할 경우 {변수}\n",
        "    + 문자열 내부에 실수인 변수를 소수점 처리할 경우 {실수변수:.소수점자리f}\n",
        "   \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bduh4-6GOOWC",
        "outputId": "80ee9eac-a8d7-49ec-987d-c83f9fb2950d"
      },
      "source": [
        "x = 3.14159\n",
        "\n",
        "print('PI = ', x)\n",
        "print(f'PI = {x:.4f}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "PI =  3.14159\n",
            "PI = 3.1416\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LAJMcsxRCDxi"
      },
      "source": [
        "## 연산자\n",
        "자료를 처리하기 위한 수식들을 결합하여 연산 동작을 수행하도록 하는 기호\n",
        "\n",
        "+ 산술연산자\n",
        "  - 수학적 계산을 수행할 때 사용하는 연산자\n",
        "  - 사칙연산자(+, -, \\*, /), 제곱(\\**), 나머지(%), 나누기 결과 정수(//)\n",
        "\n",
        "+ 비교연산자(관계연산자)\n",
        "  - 비교할 때 사용하는 연산자\n",
        "  - 등호(==), 같지 않음(!=), 부등호(<, >, <=, >=)\n",
        "\n",
        "+ 논리연산자\n",
        "  - 주어진 논리식을 판단하여, 참(true)과 거짓(false)을 결정하는 연산자\n",
        "  - and(논리곱), or(논리합), not\n",
        "\n",
        "+ 할당연산자(=)\n",
        "  - 변수에 값을 할당하기 위하여 사용하는 연산자\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Vlw4Oc-DoNm",
        "outputId": "911fc338-ce49-46bf-9d54-888159e537b7"
      },
      "source": [
        "#두 정수를 입력받아서 산술연산\n",
        "\n",
        "x = int(input())\n",
        "y = int(input())\n",
        "\n",
        "print(f'{x} + {y} = {x+y}')\n",
        "print(f'{x} - {y} = {x-y}')\n",
        "print(f'{x} x {y} = {x*y}')\n",
        "print(f'{x} / {y} = {x/y:.2f}')\n",
        "print(f'{x} / {y} 나눈 몫 : {x//y}')\n",
        "print(f'{x} / {y} 나눈 나머지 : {x%y}')\n",
        "print(f'{x}의 {y} 승 : {x**y}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "3\n",
            "10 + 3 = 13\n",
            "10 - 3 = 7\n",
            "10 x 3 = 30\n",
            "10 / 3 = 3.33\n",
            "10 / 3 나눈 몫 : 3\n",
            "10 / 3 나눈 나머지 : 1\n",
            "10의 3 승 : 1000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "giOVG8WsLqGo"
      },
      "source": [
        "## 조건문\n",
        "프로그램의 실행 흐름을 바꾸고자 할 때 사용하는 제어문\n",
        " - 사용자가 지정한 조건에 따라 실행할 문장을 결정함\n",
        "```python\n",
        "if (조건식) : \n",
        "      명령문\n",
        "elif (조건식) :\n",
        "      명령문\n",
        "else :\n",
        "      명령문\n",
        "```\n",
        "\n",
        "- if 조건문 뒤에는 반드시 콜론(:)\n",
        "- 바로 아래 문장부터 **if문에 속하는 모든 문장에 들여쓰기(indentation)**를 해야 함\n",
        "- 파이썬에는 다른 언어에 있는 switch 문이 존재하지 않음 : if...elif...elif... 문으로 수행\n",
        "- pass  : def 문이나 if 문처럼 코드 블록을 본문으로 갖는 표현에서 본문을 비워 둘 때 사용"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2UIKX01cNywh",
        "outputId": "fe5cbed6-6b44-46f0-a7d5-1b506c49860a"
      },
      "source": [
        "# 정수를 입력받아서 짝수/홀수 구분\n",
        "\n",
        "x = int(input())\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12\n",
            "12는 짝수\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QpoBs8ucO0hO"
      },
      "source": [
        "# 성적을 입력받아서 70이상이면 Pass, 70점미만 60점이상 재수강, 60점미만 Fail\n",
        "\n",
        "x = float(input('성적입력 : '))\n",
        "\n",
        " "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SSdYAZd7VKu7"
      },
      "source": [
        "## 반복문\n",
        "+ **for문** : 컬렉션으로부터 하나씩 요소(element)를 가져와, 루프 내의 문장들을 실행\n",
        "```python\n",
        "for 변수 in 컬렉션:\n",
        "    명령문\n",
        "    명령문\n",
        "    ...\n",
        "```\n",
        "\n",
        " + **range() 함수**\n",
        "```python\n",
        "range(시작숫자, 종료숫자, step)\n",
        "```\n",
        "    + 결과는 시작숫자부터 종료숫자 바로 앞 숫자까지 컬렉션 생성\n",
        "    + 값을 확인하기 위해서는 순서가 있는 리스트나 튜플 컬렉션으로 변환해야 함\n",
        "    + 시작숫자를 생략하면 0부터 생성\n",
        "    + step을 생략하면 1씩 증가\n",
        "\n",
        "  + **in** 연산자, **not in** 연산자\n",
        "    + 멤버십 연산자로 컬렉션에 속한 멤버를 확인하기 위한 연산자\n",
        "\n",
        "+ **while문** : while 키워드 다음의 조건식이 참일 경우 계속 while 안의 블럭을 실행\n",
        "```python\n",
        "while 조건식:\n",
        "    명령문\n",
        "    명령문\n",
        "    ...\n",
        "```\n",
        "+ **break 문**\n",
        "  + 반복문 안에서 루프를 빠져나오기 위해 을 사용\n",
        "\n",
        "+ **continue문**\n",
        "  + 루프 블럭의 나머지 문장들을 실행하지 않고 다음 루프로 직접 돌아가게 함 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SCXuAE5YWfCh",
        "outputId": "bdce1819-306f-4128-bd1b-68fc0f04fa7a"
      },
      "source": [
        "# 1에서 50까지 숫자 중의 3의 배수이면서 4의 배수인 수를 출력\n",
        "\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12 24 36 48 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2OVQU8sn7Ybb",
        "outputId": "62e7a448-2fb1-4259-cd84-c8ae04d02a0c"
      },
      "source": [
        "#  while문으로 변경\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12 24 36 48 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9QI5nPaNIZ6k"
      },
      "source": [
        "# **컬렉션자료형(collection data type)**\n",
        "+ 여러 요소를 묶어서 처리할 수 있는 자료형 \n",
        "+ 각 요소에 접근하는 방법이 제공\n",
        "\n",
        "<img src ='https://drive.google.com/uc?export=view&id=1qNHKZPJv546haViE6KBY3kg8gUlHJm_F' width='50%'>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bskomZoIKr0G"
      },
      "source": [
        "## 문자열 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wrbbIeVOdXc7"
      },
      "source": [
        "### 문자열 요소 접근"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CWKy8Fo7eq94"
      },
      "source": [
        "s = 'Hello Python!'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J8-r1JpUI0kS",
        "outputId": "d5d21d13-a98b-4c19-dac0-950179562c55"
      },
      "source": [
        "# 문자 출력"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "H\n",
            "e\n",
            "l\n",
            "l\n",
            "o\n",
            " \n",
            "P\n",
            "y\n",
            "t\n",
            "h\n",
            "o\n",
            "n\n",
            "!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hLhbsd1XiBFK",
        "outputId": "b2101b62-8b84-43d5-8670-d55934b78075"
      },
      "source": [
        "# 문자열에 포함된 숫자들의 합\n",
        "s = 'covid19'\n",
        "\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EeRoj_qXeTUz"
      },
      "source": [
        "### 문자열 인덱싱\n",
        " -  문자열의 각 문자는 0부터 시작되는 인덱스를 가짐\n",
        " - [인덱스]를 이용하여 인덱스위치의 문자 추출 :  처음위치 [0], 마지막위치 [-1]\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "RAggJY-wejri",
        "outputId": "596e4454-1a47-4266-a064-5321ba30d8e7"
      },
      "source": [
        "s = 'Hello Python!'\n",
        "s[-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_ECVXl6meezS"
      },
      "source": [
        "\n",
        "### 문자열 슬라이싱 \n",
        " - [인덱스1:인덱스2]: 인덱스1 위치에서 인덱스2 -1 위치까지 잘라냄\n",
        " - [인덱스1:] : 인덱스1 위치에서 끝까지 잘라냄\n",
        " - [: 인덱스2] : 처음부터 인덱스2 -1 위치까지 잘라냄"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "u7XUAQwvfSP2",
        "outputId": "4cad09d9-3bd5-4d6c-935d-716c0bebe44a"
      },
      "source": [
        "s = 'Hello Python!'\n",
        "s[2:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'llo Python!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9JuBLEqQjfRn"
      },
      "source": [
        "### 문자열 연산\n",
        "+ 문자열 더하기(+)\n",
        "+ 문자열 곱하기(*)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1K42RN_kjj1L",
        "outputId": "4935ce5a-970a-41d7-a278-3f4117db738f"
      },
      "source": [
        "s = 'Hello Python!'\n",
        "print('-' *30)\n",
        "print(s + str(2021) ) \n",
        "print('-' *30)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "------------------------------\n",
            "Hello Python!2021\n",
            "------------------------------\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AMTyZCqsfi6c"
      },
      "source": [
        "### **문자열 메소드**\n",
        "+ **len()** : 문자열 길이 구하기\n",
        "+ **count()** : 문자의 개수 구하기\n",
        "+ **find()** : 문자가 처음 나오는 위치 반환 , 없으면 -1\n",
        "+ **index()** : 문자가 처음 나오는 위치 반환, 없으면 오류\n",
        "+ **join()** : 문자열 사이에 문자 삽입, 삽입문자’.join(문자열)\n",
        "+ **upper()** :소문자를 대문자로 변환\n",
        "+ **lower()** : 대문자를 소문자로 변환\n",
        "+ **replace()** : 문자열 바꾸기\n",
        "+ **replace(원본, 변환문자)**\n",
        "+ **split()** : 문자열 나누기\n",
        " - 인수가 없으면 공백(스페이스, 탭, 엔터 등)을 기준"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sdWna_FIYErm",
        "outputId": "f1fd1d40-1074-4c81-c340-aef98850892a"
      },
      "source": [
        "data = 'a,b,c'\n",
        "lt = data.split(',')\n",
        "lt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'c']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ijNhIH6CmrXJ"
      },
      "source": [
        "## **리스트(list)**\n",
        " - 리스트의 각 요소는 순서를 가지고 있음\n",
        " - 대괄호([])로 작성되며 각 요소는 쉼표(,)로 구분\n",
        " - 요소를 추가, 수정, 삭제 가능"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3SrhTGkinJz7"
      },
      "source": [
        "### 리스트 생성\n",
        "+ []나 리스트 함수"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9BAADR6snRE5"
      },
      "source": [
        "lt = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DT3ToqCOoJKi"
      },
      "source": [
        "### 리스트 요소 접근"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9b4wEJ17oNLo",
        "outputId": "ae3cae06-8b67-4eef-ddd3-eddf0d681660"
      },
      "source": [
        "lt = ['1', '2', '3', '4', '5']\n",
        "\n",
        "#반복문을 이용한 리스트 접근\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 2 3 4 5 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SXiWEUoxYobZ",
        "outputId": "6405fec4-fd9b-4aa5-8004-2ff766f9dcae"
      },
      "source": [
        "#반복문을 이용하여 리스트 요소 정수로 변경\n",
        " \n",
        "\n",
        "lt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CzTw-YF0oiq5",
        "outputId": "2f0af542-c7b2-4e9c-99ca-d080dd81ef39"
      },
      "source": [
        "lt = ['1', '2', '3', '4', '5']\n",
        "print(f'{lt} => {type(lt)}')\n",
        "\n",
        "lt = [int(i) for i in lt]\n",
        "print(f'{lt} => {type(lt)}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['1', '2', '3', '4', '5'] => <class 'list'>\n",
            "[1, 2, 3, 4, 5] => <class 'list'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ih2lzZgSnXr6"
      },
      "source": [
        "### 리스트 인덱싱\n",
        " - 요소의 선택은 0부터 시작되는 인덱스로 접근\n",
        " - 리스트명[인덱스]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7d_oMnoinapv",
        "outputId": "97ed5783-e3af-4398-87f1-9c9feca4ff67"
      },
      "source": [
        "lt = [1 , 3, 5]\n",
        "print(lt[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4kkhezktnt7Z"
      },
      "source": [
        "### 리스트 슬라이싱\n",
        " - 요소의 일부분 선택\n",
        " - 리스트명[시작인덱스:종료인덱스] : 종료인덱스는 포함되지 않음"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7xe1tbXvnzG5",
        "outputId": "401bbfc4-0ff7-4760-be8d-6bd8bc13fa6b"
      },
      "source": [
        "lt = [1 , 3, 5]\n",
        "print(lt[1:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TdtqmVq-pRDQ"
      },
      "source": [
        "### 리스트 연산\n",
        "+ 더하기(+) : 리스트와 리스트 연결\n",
        "+ 곱하기(*) : 리스트 요소 반복"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yr-2ScgTpbe4",
        "outputId": "397ddcd8-fa28-4db7-ce2e-5115d695809a"
      },
      "source": [
        "lt1 = [1, 2, 3]\n",
        "lt2 = [3, 4, 5]\n",
        "\n",
        "print(lt1 + lt2)\n",
        "print(lt1 * 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 3, 4, 5]\n",
            "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mXjykxxSqMzy"
      },
      "source": [
        "### 리스트 변경\n",
        "* 추가\n",
        " - 리스트명.append(추가요소) : 마지막에 추가\n",
        " - 리스트명.insert(인덱스, 추가요소) : 해당 인덱스에 요소 추가\n",
        "\n",
        "* 삭제\n",
        " - 리스트명.pop() : 마지막 요소 삭제\n",
        " - 리스트명.pop(인덱스) : 해당 인덱스 요소 삭제\n",
        " - 리스트명.remove(요소값) : 해당 요소값 삭제, 해당 값이 없으면 오류\n",
        "\n",
        "* 수정\n",
        " - 리스트명[인덱스]=변경값\n",
        " - (참고) isinstance()함수 : 특정 객체가 특정 타입인지에 대해서 확인할 수 있는 방법"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O-i_PPx-qQdh",
        "outputId": "13173a7e-6180-4fd4-ae36-167cd93d5cac"
      },
      "source": [
        "# 정수를 입력받아서 약수리스트를 구하기\n",
        "\n",
        "n = int(input())\n",
        "\n",
        " \n",
        " \n",
        "print(lt)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "[1, 2, 5, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sjMZQUazwNFi"
      },
      "source": [
        "### 리스트 메소드\n",
        "+ 리스트명.index(요소값) : 해당 요소값의 위치를 반환\n",
        " - 여러 개 요소가 존재하면 첫번째 위치 반환하고 없으면 오류\n",
        "+ 리스트명.count(요소값) : 리스트 요소 개수 구하기\n",
        "+ 리스트명.sort() : 오름차순 리스트 정렬\n",
        " - 리스트명.sort(reverse=True): 내림차순\n",
        "+ 리스트명.reverse() : 요소를 역순으로 뒤집어 줌 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_aYHNYCkZcdA"
      },
      "source": [
        "lt = [1, 2, 3, 2, 5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iugo5QzwZxPi"
      },
      "source": [
        "lt.reverse()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pptsA5GBZzwU",
        "outputId": "f7b8cd9f-a05f-4d56-dc12-946653d3a932"
      },
      "source": [
        "lt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 2, 3, 2, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hPGfZkPRZeUw"
      },
      "source": [
        "lt.sort()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xt9Bgn-WZr0G",
        "outputId": "930f4557-4c62-48c8-9770-417d81f91609"
      },
      "source": [
        "lt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 2, 3, 5]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7AJ45VMez0J1"
      },
      "source": [
        "### 리스트 내장함수\n",
        "* sum() : 리스트의 합을 반환\n",
        "* min() : 리스트 최소값 반환\n",
        "* max() : 리스트 최대값 반환\n",
        "* len() : 리스트 개수 반환"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyS_EUW72Rkg"
      },
      "source": [
        "## 튜플(tuple) \n",
        "+ 튜플의 각 요소는 순서를 가지고 있음\n",
        "+ 괄호(())로 작성되며 각 요소는 쉼표(,)로 구분\n",
        "+ 요소를 추가, 수정, 삭제 불가능\n",
        "+ **한번 결정된 요소는 변경 불가능**\n",
        "+ **인덱싱과 슬라이싱은 리스트와 동일**\n",
        "+ $+$와 $*$연산은 리스트와 동일\n",
        "+ 각 요소에 변수 할당 가능\n",
        " - x, y = (10, 20)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zu9JAJs22niA"
      },
      "source": [
        "---\n",
        "\n",
        "**생각해보기)**\n",
        "\n",
        "\n",
        "---\n",
        "튜플의 내용을 변경하고 싶을 경우는?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "id": "Fcu2mCZNaEmk",
        "outputId": "2d223007-3e17-4185-d360-2fb5edbd2146"
      },
      "source": [
        "tp = (1, 2)\n",
        "tp[0] =10"
      ],
      "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-30-c4677cfcd64a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtp\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;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtp\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;36m10\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": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-JivTjSJaJX2",
        "outputId": "e059d80c-d1c0-45db-95bc-647e4a6f3826"
      },
      "source": [
        "#튜플의 내용 변경해 보기\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VXfYSOdW8adn"
      },
      "source": [
        "## 딕션너리(dictionary)\n",
        " - 키(key)와 값(value) 쌍을 요소로 가짐\n",
        " - 중괄호({})로 작성되며 각 요소는 쉼표(,)로 구분\n",
        " - 순서 없음 \n",
        " - 키는 변경할 수 없으며 값은 변경가능 \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ngtkAr4y9h6p"
      },
      "source": [
        "areadata = {'서울시':57, '부산시':62, '대구시':59, \n",
        "            '인천시':59, '강화군':58, '서해5도' : 64, \n",
        "            '광주시' :62, '대전시':60, '울산시':53, \n",
        "            '세종시':58\t}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8BUk47wo8gvW"
      },
      "source": [
        "### **딕션너리 접근**\n",
        " - 특정 요소 값 가져오기\n",
        "   + **딕션너리명[키]**\n",
        "   + **닥션너리명.get(키값)**\n",
        "    + Key에 대응되는 Value를 돌려줌\n",
        "    + 딕션너리명[키값]인 것과 동일 \n",
        "    + 차이점 : 키가 없을 경우 딕션너리명[키값]은 오류이고 get()으로 가져올 경우는 none\n",
        " - 요소 키 컬렉션  : 딕션너리명.keys()\n",
        " - 요소 값 컬렉션 : 딕션너리명.values()\n",
        " - 키와 요소 컬렉션은 list() 생성자로 리스트로 변환가능\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HM3IT7dN-B9q",
        "outputId": "ee430889-2975-4f11-be79-c0dc03d55ae2"
      },
      "source": [
        "areadata"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'강화군': 58,\n",
              " '광주시': 62,\n",
              " '대구시': 59,\n",
              " '대전시': 60,\n",
              " '부산시': 62,\n",
              " '서울시': 57,\n",
              " '서해5도': 64,\n",
              " '세종시': 58,\n",
              " '울산시': 53,\n",
              " '인천시': 59}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HAehExR0bs1x",
        "outputId": "b0113cd3-f5c8-4f29-c209-42c3873ce2ac"
      },
      "source": [
        "areadata['부산시']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "62"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cr-NHWl6bwrG"
      },
      "source": [
        "areadata.get('부산')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qEVj_-9Ab83u"
      },
      "source": [
        "klt = list(areadata.keys())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PCKIeZ_tcGKI"
      },
      "source": [
        "vlt = list(areadata.values())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8HdIQNascPZy",
        "outputId": "48b283c5-540f-41e9-81ac-90dcb2c43c7a"
      },
      "source": [
        "#반복문을 이용하여 딕션너리 내용 출력하기\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "서울시 57\n",
            "부산시 62\n",
            "대구시 59\n",
            "인천시 59\n",
            "강화군 58\n",
            "서해5도 64\n",
            "광주시 62\n",
            "대전시 60\n",
            "울산시 53\n",
            "세종시 58\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wcvGK9OEceLR",
        "outputId": "638ec5e6-dd96-424b-d1ba-3494da31fc97"
      },
      "source": [
        "#반복문을 이용하여 딕션너리 내용 출력하기 : 키와 값을 튜플로 출력\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('서울시', 57)\n",
            "('부산시', 62)\n",
            "('대구시', 59)\n",
            "('인천시', 59)\n",
            "('강화군', 58)\n",
            "('서해5도', 64)\n",
            "('광주시', 62)\n",
            "('대전시', 60)\n",
            "('울산시', 53)\n",
            "('세종시', 58)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "70XD8M-ecuW0",
        "outputId": "f53b479a-1487-423f-e4d1-36c59cdd365f"
      },
      "source": [
        "#반복문을 이용하여 딕션너리 내용 튜플을 이용하여 출력하기 \n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "서울시 57\n",
            "부산시 62\n",
            "대구시 59\n",
            "인천시 59\n",
            "강화군 58\n",
            "서해5도 64\n",
            "광주시 62\n",
            "대전시 60\n",
            "울산시 53\n",
            "세종시 58\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A7PVvgK3CCOq"
      },
      "source": [
        "## 집합(set)\n",
        "+ **특징**\n",
        " - 중복 없는 요소로만 구성\n",
        " - 중괄호({}) 작성되며 각 요소는 쉼표(,)로 구분\n",
        " - 순서 없음\n",
        "\n",
        "+ **생성자 set()**\n",
        " - 리스트나 튜플의 중복 요소 제거 \n",
        "\n",
        "+ **요소 추가**\n",
        " - 집합명.add(요소) : 하나의 요소 추가\n",
        " - 집합명.update(추가집합) : 여러 요소를 추가\n",
        "\n",
        "+ **요소 삭제**\n",
        " - 집합명.remove(요소값) : 하나의 요소 삭제\n",
        " - 집합명.clear() : 모든 요소 삭제\n",
        " \n",
        "+ **집합 연산**\n",
        " - 교집합 : &\n",
        " - 합집합 : |\n",
        " - 차집합 : -"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vi9kDbZC73c",
        "outputId": "58abc975-51e8-4768-ca4b-ca15270ce16f"
      },
      "source": [
        "lt = [11, 3,1, 2, 2, 3,3, 5]\n",
        "lt = list(set(lt))\n",
        "print(lt)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 5, 11]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gXPzTZdiDTtL"
      },
      "source": [
        "## **zip()**\n",
        "+ 동일한 개수로 이루어진 컬렉션 자료형을 묶어 주는 역할을 하는 함수"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HpDhVc_odIX-",
        "outputId": "9f42e0c2-4e1b-43f7-b09e-7423bc51989f"
      },
      "source": [
        "print(klt,  len(klt))\n",
        "print(vlt,  len(vlt))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['서울시', '부산시', '대구시', '인천시', '강화군', '서해5도', '광주시', '대전시', '울산시', '세종시'] 10\n",
            "[57, 62, 59, 59, 58, 64, 62, 60, 53, 58] 10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PWgMzT8cddIt",
        "outputId": "142668b5-be9d-4664-df1b-65c35d6b168d"
      },
      "source": [
        "#두 리스트를 딕션너리로 만들기\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{53: '울산시', 57: '서울시', 58: '세종시', 59: '인천시', 60: '대전시', 62: '광주시', 64: '서해5도'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fmBetaMKDg3-",
        "outputId": "5c3ca792-785a-41e3-ebc6-c16adfae9b86"
      },
      "source": [
        "#리스트와 튜플을 딕션너리로 만들기\n",
        "lt = [10,50,30]\n",
        "tp = ('a','b','c')\n",
        "\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'a': 10, 'b': 50, 'c': 30}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xNGHaezSDpGy",
        "outputId": "7f103baa-fb63-4cdf-f921-d585b1a4533f"
      },
      "source": [
        "#리스트와 튜플을 리스트로 만들기\n",
        "dt2 = list(zip(tp, lt))\n",
        "print(dt2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[('a', 10), ('b', 50), ('c', 30)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t8KsEMJzDxdz",
        "outputId": "10173c26-b50f-4b2f-e8da-023fbf58f976"
      },
      "source": [
        "#리스트와 튜플을 리스트로 만들기2 : 리스트의 요소를 리스트로 변환\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[['a', 10], ['b', 50], ['c', 30]]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}