1_Pandas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "0-Pandas.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JSJeong-me/2021-K-Digital-Training/blob/main/1_Pandas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VRB-sWlqYIup"
      },
      "source": [
        "## Google Colab 사용 방법\n",
        "\n",
        "- 방향키 ↑↓: 셀 간 이동\n",
        "- Enter: 편집모드\n",
        "- Ctrl + Enter: 셀 실행\n",
        "- Shift + Enter: 셀 실행 + 다음 셀 선택\n",
        "\n",
        "---\n",
        "\n",
        "- Ctrl +M D: 셀 삭제\n",
        "- Ctrl + M K: 셀 위로 이동\n",
        "- Ctrl + M J: 셀 아래로 이동"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yAWciHLQszCL"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PKpOg-rotBW4"
      },
      "source": [
        "# 1. Pandas\n",
        "\n",
        "Pandas는 다음과 같은 특징을 같습니다.\n",
        "- NumPy를 내부적으로 활용함(NumPy의 특징을 그대로 가짐)\n",
        "- 데이터분석에 특화된 데이터 구조 제공\n",
        "- 다양한 데이터 분석 함수 제공\n",
        "- 데이터베이스에 쉽게 연결 가능\n",
        "\n",
        "## Cheat Sheet\n",
        "\n",
        "판다스는 많은 기능을 제공합니다. 이번 강의에서는 이러한 기능들을 학습할 예정입니다.</br>\n",
        "그러나 이 모든 기능을 외울 순 없습니다. 외울 필요도 없고요.\n",
        "\n",
        "**아래는 판다스를 한 장에 정리해 둔 치트시트입니다**\n",
        "\n",
        "어떠한 기능들을 하는 함수들이 있다는것만 학습한 뒤 해당 기능이 필요할 때 아래의 치트시트를 참조해가며 판다스를 사용하면 됩니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pX5WXMBTu9ag"
      },
      "source": [
        "![](http://drive.google.com/uc?export=view&id=12qAWxrdhFmdYN61uYbqM58jHm1y9PWJ3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQR47prJwEF0"
      },
      "source": [
        "파이썬에서 pandas를 사용할 때는 일반적으로 다음과 같이 pd형태로 임포트해서 사용합니다"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "38c6YhsGs0Tv"
      },
      "source": [
        "import pandas as pd"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "JAiLRzP6CLF4",
        "outputId": "f5492fd1-906f-4cbc-cb3d-8606b4100fb0"
      },
      "source": [
        "pd.__version__"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1.1.5'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8yP45ujfS8vk"
      },
      "source": [
        "# numpy와 matplotlib 임포트\n",
        "# %matplotlib inline # 노트북에서 그래프를 보여주기 위해 추가해주는 코드\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hNImNha73T5l"
      },
      "source": [
        "Pandas의 모든 API는 help 함수를 이용하여 도움말을 확인할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZ4ZjzFZ3UZz"
      },
      "source": [
        "# help(pd)\n",
        "# help(pd.read_csv)\n",
        "help(pd.DataFrame)\n",
        "# pd.DataFrame?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-yNHIoMstJZl"
      },
      "source": [
        "# 2. Pandas 데이터 구조"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AK3p2FFkxWz6"
      },
      "source": [
        "![](http://drive.google.com/uc?export=view&id=1B0ZpHC2hCXfoeYKxMT4DRHqKrQbEbztj)\n",
        "\n",
        "## Series\n",
        "- 1차원 데이터 구조\n",
        "- 일반적으로 s 또는 sr로 이름 붙임\n",
        "\n",
        "![](http://drive.google.com/uc?export=view&id=1msqZqjnrFLJXlaBGF7DsLf2B0_lA_J07)\n",
        "\n",
        "Series는 **pd.Series()** 로 생성합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wSCeAj_pCpgO"
      },
      "source": [
        "import pandas"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "doteWblhtMxj"
      },
      "source": [
        "s = pandas.Series([3, -5, 7, 4]) # 인덱스 없이 생성"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Msp-X6nixlnY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8512e2b0-e3d1-411a-8c7a-ba8622eed073"
      },
      "source": [
        "s"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    3\n",
              "1   -5\n",
              "2    7\n",
              "3    4\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kyR1c_cDC0pB",
        "outputId": "6ae994dc-0ed9-449c-84fc-453fb2e540b1"
      },
      "source": [
        "s[0]"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VKIHjVrxC4z8",
        "outputId": "5d1f9023-d09a-4c43-a6eb-09a6130f9933"
      },
      "source": [
        "s[3]"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MRX_FxMuC-ry",
        "outputId": "c8cadc5b-3ba6-4555-a5a8-74619ca3d0d4"
      },
      "source": [
        "s[:]"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    3\n",
              "1   -5\n",
              "2    7\n",
              "3    4\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o93uplaoDBx_",
        "outputId": "4a871cd9-f6d3-4e36-ce76-8bc0a0b3a56f"
      },
      "source": [
        "s[0:4]"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    3\n",
              "1   -5\n",
              "2    7\n",
              "3    4\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SRc6GQUKU64O"
      },
      "source": [
        "인덱스를 특별히 지정해주지 않으면 NumPy 다차원배열처럼 0부터 인덱스가 시작됩니다.\n",
        "\n",
        "NumPy 다차원 배열과 다르게 Pandas Series는 인덱스를 지정해 줄 수 있으며 숫자가 아닌 문자열도 인덱스가 될 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iOpUNH4ZGldy"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ErsjLCMSGdrG"
      },
      "source": [
        "data = [3, -5, 7, 4]"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3nUYDZ3gU7X_"
      },
      "source": [
        "s = pandas.Series(data, index=['a', 'b', 'c', 'd'])"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KokRyLH9U7yd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e80ab61b-472a-4ee9-efe1-4770050b2349"
      },
      "source": [
        "s"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "a    3\n",
              "b   -5\n",
              "c    7\n",
              "d    4\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n4zxdtBDGp3X"
      },
      "source": [
        "s = pandas.Series(data, index=['가', '나', '다', '라'])"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zTBDf26gG3Ak",
        "outputId": "25593796-2737-4987-b08c-d3f6d21e1310"
      },
      "source": [
        "s"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "가    3\n",
              "나   -5\n",
              "다    7\n",
              "라    4\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G88ENaia4xvy"
      },
      "source": [
        "**type()**을 통해 데이터타입이 Series인 걸 확인할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4cGRxYi1KX5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d13b5b23-2f62-424e-cab0-865fd80edb18"
      },
      "source": [
        "type(s)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "pandas.core.series.Series"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhuUWc2ZYEO5"
      },
      "source": [
        "### 속성"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "24tY76qdTh1S"
      },
      "source": [
        "Series는 index와 values를 가집니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mNOuTlUKTkrJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7fbf93e8-8908-4870-93b2-eedbcbca963f"
      },
      "source": [
        "s.index"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['가', '나', '다', '라'], dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QOpkc9SATknp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac9b3b04-b6ee-412a-82e3-e73d1f17e9fa"
      },
      "source": [
        "s.values"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 3, -5,  7,  4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mIXMjiDoHXk0",
        "outputId": "07f30b80-10eb-4a07-9d0c-d23f1fc8ee58"
      },
      "source": [
        "s.dtype"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OZOCdEIpHecr",
        "outputId": "095feabb-ce33-4c56-cde4-98b82072b8af"
      },
      "source": [
        "s.shape"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t0SoEs_oHxEH",
        "outputId": "8733669e-3df9-4342-8539-7ca1062cba16"
      },
      "source": [
        "s.ndim"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MGOXLUypIBug",
        "outputId": "019b2134-8d64-49eb-ed2a-383e83a5a683"
      },
      "source": [
        "s.value_counts"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<bound method IndexOpsMixin.value_counts of 가    3\n",
              "나   -5\n",
              "다    7\n",
              "라    4\n",
              "dtype: int64>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MvPMnq8tYF6G"
      },
      "source": [
        "### 인덱싱"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JLRJKNh_TxDp"
      },
      "source": [
        "Series는 요소는 index명 또는 index의 순서를 통해 인덱싱할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HxichMzXToNB"
      },
      "source": [
        "# index명으로 조회\n",
        "s['a']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_U60FIMMTkiA"
      },
      "source": [
        "# index순서로 조회\n",
        "s[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h25RGBmaYLLI"
      },
      "source": [
        "### 파이썬 딕셔너리와 Pandas Series의 공통점, 차이점"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t1UVLe3CU1bP"
      },
      "source": [
        "Index와 value를 가진다는 점에서 key와 value를 가지는 파이썬 딕셔너리와 유사하다 볼 수 있습니다.\n",
        "\n",
        "그렇기에 파이썬 딕셔너리를 통해 Series를 생성할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1lmS9H8KVmYc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b532c462-e949-4cee-f5c3-1f33aba7431f"
      },
      "source": [
        "# pop_dict는 파이썬 딕셔너리\n",
        "pop_dict = {'Germany': 81.3, \n",
        "            'Belgium': 11.3, \n",
        "            'France': 64.3, \n",
        "            'United Kingdom': 64.9, \n",
        "            'Netherlands': 16.9}\n",
        "\n",
        "# pop_dict로 Series 생성\n",
        "population = pandas.Series(pop_dict)\n",
        "population"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Germany           81.3\n",
              "Belgium           11.3\n",
              "France            64.3\n",
              "United Kingdom    64.9\n",
              "Netherlands       16.9\n",
              "dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eMr79qK7V2O7"
      },
      "source": [
        "딕셔너리에서 key값을 이용해 value를 조회하듯 Series에서 index를 이용해 value를 조회할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UM5IIA3fI7YV",
        "outputId": "dd17ffe0-57c8-405a-a581-47db8c1e5a04"
      },
      "source": [
        "population"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Germany           81.3\n",
              "Belgium           11.3\n",
              "France            64.3\n",
              "United Kingdom    64.9\n",
              "Netherlands       16.9\n",
              "dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9I1TeWdVWMYY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c97c98bb-306a-4b13-f6fb-59416a4c17ca"
      },
      "source": [
        "pop_dict['United Kingdom']"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "64.9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6aKhymr5zerK"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "st0IKIMzV5IX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d711a5a4-2997-49fb-a486-3af25b82a636"
      },
      "source": [
        "population['France']"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "64.3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AzyUebKvWC2J"
      },
      "source": [
        "딕셔너리와 Series의 차이점은, 딕셔너리의 Key는 순서가 없고 pandas Series의 index는 순서가 있다는 점입니다.\n",
        "그렇기에 Series는 index의 순서를 통해서도 value 조회가 가능합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mmq8pkx9WYie",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ec896e9-3706-4177-d33e-3ff585514e13"
      },
      "source": [
        "# KeyError 발생(2라는 Key 값은 없음)\n",
        "pop_dict['Germany']"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "81.3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R6dTfwFsWVuD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "91bcbd16-0fa7-4c09-80d5-fc410d2f83ff"
      },
      "source": [
        "population[4]"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16.9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T5UZTQzOJ-AJ",
        "outputId": "693ea2c0-5e90-42dc-ffe7-ebb2cf56f0b1"
      },
      "source": [
        "population[:]"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Germany           81.3\n",
              "Belgium           11.3\n",
              "France            64.3\n",
              "United Kingdom    64.9\n",
              "Netherlands       16.9\n",
              "dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hNaLUhGjKBlT"
      },
      "source": [
        "population[0:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLs-gxb9WrQg"
      },
      "source": [
        "또한 Series는 딕셔너리와 다르게 아래와 같은 연산이 가능합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bAFr4JvALeDY",
        "outputId": "184a39ca-0016-4d7e-fd3e-508dd80c1a28"
      },
      "source": [
        "population.index"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['Germany', 'Belgium', 'France', 'United Kingdom', 'Netherlands'], dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O_dGZfEiKsQl",
        "outputId": "b43ca0ef-8e8d-4049-b548-e4dac056206c"
      },
      "source": [
        "  population[-2]"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "64.9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GnmNuWBVKP00",
        "outputId": "9006fe5e-17ce-4c3f-e40b-1813b89e60b0"
      },
      "source": [
        "population.dtype"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C5_h-zgDVoQ7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9ea868de-f2bb-44d7-bb81-6eff3ec9b2c0"
      },
      "source": [
        "population*1000"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Germany           81300.0\n",
              "Belgium           11300.0\n",
              "France            64300.0\n",
              "United Kingdom    64900.0\n",
              "Netherlands       16900.0\n",
              "dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3w7YrxnFKW5d"
      },
      "source": [
        "population"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cfh8lqWDKdNH"
      },
      "source": [
        "pop_dict.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z1cd8YubWnvh"
      },
      "source": [
        "# TypeError발생 (dict * int)\n",
        "pop_dict * 1000"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhWewv3-T_V2"
      },
      "source": [
        "## 참고. Index가 문자열에 저장된 숫자일 경우\n",
        "\n",
        "Series의 요소를 조회하는데 혼돈이 올 수 있으니 숫자 Index를 원할 경우,\n",
        "- 문자가 아닌 정수형으로 index를 지정합시다.\n",
        "- 1이 아닌 0부터 index를 지정합시다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hg58y-X8T_0u"
      },
      "source": [
        "sr = pd.Series([1, 2, 3, 4], index=['1', '2', '3', '4'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WFVUKnzKUG5r"
      },
      "source": [
        "# index명으로 접근\n",
        "sr['1']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__cA7-tQUHAU"
      },
      "source": [
        "# index순서로 접근\n",
        "sr[1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2clmO3DzMwOz",
        "outputId": "1734cdf1-1ee9-45af-c202-613c0528dbbc"
      },
      "source": [
        "population"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Germany           81.3\n",
              "Belgium           11.3\n",
              "France            64.3\n",
              "United Kingdom    64.9\n",
              "Netherlands       16.9\n",
              "dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w0qclLbeYZ7R"
      },
      "source": [
        "DataFrame에서도 마찬가지로 숫자 Index를 사용할 경우 염두해두어야 합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c_SOMZ_jxm1j"
      },
      "source": [
        "## DataFrame\n",
        "- 2차원 데이터 구조\n",
        "- 일반적으로 df로 이름 붙임\n",
        "- 엑셀 스프레드시트, 데이터베이스등과 동일한 2차원 구조\n",
        "- 가장 많이 활용하게될 구조\n",
        "- Series가 합쳐진 형태\n",
        "\n",
        "![](http://drive.google.com/uc?export=view&id=1lixriaQy119N0nNM0e_TTQ1DfuSNMk76)\n",
        "\n",
        "DataFrame은 **pd.DataFrame()** 으로 생성합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lDU7pjLOXMV1"
      },
      "source": [
        "중첩된 리스트나 딕셔너리를 통해 DataFrame을 생성할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ng-KW4O5RD_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "dbab97e0-af7c-4344-c33d-f8089455f5bd"
      },
      "source": [
        "# 중첩된 리스트를 통한 데이터 생성\n",
        "# 각 행을 리스트로 만들어야 함\n",
        "data = [['Belgium', 'Brussels', 11190846],\n",
        "        ['India', 'New Delhi', 1303171035],\n",
        "        ['Brazil', 'Brasília', 207847528]]\n",
        "\n",
        "df = pandas.DataFrame(data)\n",
        "\n",
        "df"
      ],
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0</th>\n",
              "      <th>1</th>\n",
              "      <th>2</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Belgium</td>\n",
              "      <td>Brussels</td>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>India</td>\n",
              "      <td>New Delhi</td>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Brazil</td>\n",
              "      <td>Brasília</td>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "         0          1           2\n",
              "0  Belgium   Brussels    11190846\n",
              "1    India  New Delhi  1303171035\n",
              "2   Brazil   Brasília   207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MwsXq0kZNTQb",
        "outputId": "23665127-d473-4807-c103-43d105b0fb13"
      },
      "source": [
        "df[0]"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    Belgium\n",
              "1      India\n",
              "2     Brazil\n",
              "Name: 0, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J_UU1gGkNqWu",
        "outputId": "155cbba9-687f-4497-8ca2-b461f3e34be4"
      },
      "source": [
        "df[1]"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0     Brussels\n",
              "1    New Delhi\n",
              "2     Brasília\n",
              "Name: 1, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KujLru8ENsno"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T26fEspK6bfp"
      },
      "source": [
        "columns 파라메터를 통해 칼럼명 역시 정해줄 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jdb1iQCU6VEM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "c5a37060-b1fe-444a-c1f9-cf44341ddaeb"
      },
      "source": [
        "# 중첩된 리스트를 통한 데이터 생성\n",
        "# 각 행을 리스트로 만들어야 함\n",
        "data = [['Belgium', 'Brussels', 11190846],\n",
        "        ['India', 'New Delhi', 1303171035],\n",
        "        ['Brazil', 'Brasília', 207847528]]\n",
        "\n",
        "df = pandas.DataFrame(data, columns=['Country', 'Capital', 'Population'])\n",
        "\n",
        "df"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Country</th>\n",
              "      <th>Capital</th>\n",
              "      <th>Population</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Belgium</td>\n",
              "      <td>Brussels</td>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>India</td>\n",
              "      <td>New Delhi</td>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Brazil</td>\n",
              "      <td>Brasília</td>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Country    Capital  Population\n",
              "0  Belgium   Brussels    11190846\n",
              "1    India  New Delhi  1303171035\n",
              "2   Brazil   Brasília   207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-D6cOpWaOAvE",
        "outputId": "5a84f75d-2aea-4ecd-bf7a-d8e75c3f342a"
      },
      "source": [
        "df['Country']"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    Belgium\n",
              "1      India\n",
              "2     Brazil\n",
              "Name: Country, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kizANc2GOGMV",
        "outputId": "c606c92c-9b0f-49aa-cae4-2035622ed84d"
      },
      "source": [
        "df.Country"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    Belgium\n",
              "1      India\n",
              "2     Brazil\n",
              "Name: Country, dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cytnMis_5o6z"
      },
      "source": [
        "데이터프레임의 데이터는 딕셔너리로 넘겨주는게 일반적입니다.\n",
        "\n",
        "- 칼럼명을 함께 넘겨줄 수 있기 때문입니다.\n",
        "- **동일한 데이터타입끼리 함께 묶어서 넘겨줄 수 있기 때문입니다.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NFntK2xQyiPE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "7c09e3de-3a7c-454f-dec4-996f8e6a80c3"
      },
      "source": [
        "data = {'Country': ['Belgium', 'India', 'Brazil'],\n",
        "        'Capital': ['Brussels', 'New Delhi', 'Brasília'],\n",
        "        'Population': [11190846, 1303171035, 207847528]}\n",
        "\n",
        "df = pandas.DataFrame(data)\n",
        "\n",
        "df"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Country</th>\n",
              "      <th>Capital</th>\n",
              "      <th>Population</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Belgium</td>\n",
              "      <td>Brussels</td>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>India</td>\n",
              "      <td>New Delhi</td>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Brazil</td>\n",
              "      <td>Brasília</td>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Country    Capital  Population\n",
              "0  Belgium   Brussels    11190846\n",
              "1    India  New Delhi  1303171035\n",
              "2   Brazil   Brasília   207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GSOca-hb6pMi"
      },
      "source": [
        "칼럼명과 마찬가지로 인덱스 역시 변경할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9SKuwsU6yk9N",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "dd51beae-5269-4131-c8b1-713ef50d1fa0"
      },
      "source": [
        "data = {'Country': ['Belgium', 'India', 'Brazil'],\n",
        "        'Capital': ['Brussels', 'New Delhi', 'Brasília'],\n",
        "        'Population': [11190846, 1303171035, 207847528]}\n",
        "\n",
        "df_2 = pandas.DataFrame(data,\n",
        "                    index=['aa', 'bb', 'cc'])\n",
        "\n",
        "df_2"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Country</th>\n",
              "      <th>Capital</th>\n",
              "      <th>Population</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>aa</th>\n",
              "      <td>Belgium</td>\n",
              "      <td>Brussels</td>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>bb</th>\n",
              "      <td>India</td>\n",
              "      <td>New Delhi</td>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>cc</th>\n",
              "      <td>Brazil</td>\n",
              "      <td>Brasília</td>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "    Country    Capital  Population\n",
              "aa  Belgium   Brussels    11190846\n",
              "bb    India  New Delhi  1303171035\n",
              "cc   Brazil   Brasília   207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nanFpU7S07zL"
      },
      "source": [
        "**type()**을 통해 데이터타입이 DataFrame인 걸 확인할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yNtFh6z51Fzh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a598c91-41bf-45bd-ed42-1a3bf5ff1947"
      },
      "source": [
        "type(df)"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "pandas.core.frame.DataFrame"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lLDAnDLW1Nch"
      },
      "source": [
        "데이터프레임의 하나의 열은 어떤 데이터구조로 되어있을까요?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fYiwdVogO620",
        "outputId": "c4892f57-01af-4cae-89af-336f3d8f3b5f"
      },
      "source": [
        "df.info()"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 3 entries, 0 to 2\n",
            "Data columns (total 3 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   Country     3 non-null      object\n",
            " 1   Capital     3 non-null      object\n",
            " 2   Population  3 non-null      int64 \n",
            "dtypes: int64(1), object(2)\n",
            "memory usage: 200.0+ bytes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KBbzpqfFPGRU",
        "outputId": "005a9668-a516-4367-fdbf-dba51d1d2227"
      },
      "source": [
        "df.Country.dtype"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('O')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBB_KeuY08Xp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17920dfa-d3ca-42e3-e558-5b866689dec2"
      },
      "source": [
        "type(df['Country'])"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "pandas.core.series.Series"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1AeevSeHzerY"
      },
      "source": [
        "df.Country"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TxseQAKI1U22"
      },
      "source": [
        "데이터프레임 각 열의 데이터타입은 Series라는걸 알 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CuKrfCFZXzfM"
      },
      "source": [
        "### 속성\n",
        "\n",
        "아래와 같은 속성을 가집니다.\n",
        "\n",
        "- index\n",
        "- columns\n",
        "- dtypes\n",
        "- values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FeLlouFuX2xg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cdce2590-20f5-4bb3-d881-0666fef61c06"
      },
      "source": [
        "df.index"
      ],
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RangeIndex(start=0, stop=3, step=1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CAle5ksHY94i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d40d59b-511c-41b8-9a42-f44d4c4be976"
      },
      "source": [
        "df.columns"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['Country', 'Capital', 'Population'], dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WyVwLH5nY9tZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c28268f3-60ba-437b-eca1-5d89e28a6a83"
      },
      "source": [
        "df.dtypes"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Country       object\n",
              "Capital       object\n",
              "Population     int64\n",
              "dtype: object"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1_gOFVdmZHBI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc4db804-9840-4171-80dd-3dae59b3f5cc"
      },
      "source": [
        "df.values"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([['Belgium', 'Brussels', 11190846],\n",
              "       ['India', 'New Delhi', 1303171035],\n",
              "       ['Brazil', 'Brasília', 207847528]], dtype=object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KINUU5yxZM3f"
      },
      "source": [
        "Index, columns, dtypes를 한번에 조회하고 싶다면 info()를 사용하세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j062-g28Y9G6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e51d6c5d-cd2a-4250-ae93-528179011362"
      },
      "source": [
        "df.info()"
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 3 entries, 0 to 2\n",
            "Data columns (total 3 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   Country     3 non-null      object\n",
            " 1   Capital     3 non-null      object\n",
            " 2   Population  3 non-null      int64 \n",
            "dtypes: int64(1), object(2)\n",
            "memory usage: 200.0+ bytes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v8tklKsAZsl3"
      },
      "source": [
        "특정한 칼럼을 index로 사용할수도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h0bOGfoEZG7E",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "4054d543-1a62-4d56-8e1d-a5775739bc36"
      },
      "source": [
        "df"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Country</th>\n",
              "      <th>Capital</th>\n",
              "      <th>Population</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Belgium</td>\n",
              "      <td>Brussels</td>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>India</td>\n",
              "      <td>New Delhi</td>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Brazil</td>\n",
              "      <td>Brasília</td>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Country    Capital  Population\n",
              "0  Belgium   Brussels    11190846\n",
              "1    India  New Delhi  1303171035\n",
              "2   Brazil   Brasília   207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1sZg4i5pZ2H2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "f15d11fd-9acb-4e4c-beed-bd50093e5277"
      },
      "source": [
        "df_index_with_country = df.set_index('Country')\n",
        "\n",
        "df_index_with_country"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Capital</th>\n",
              "      <th>Population</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Country</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>Belgium</th>\n",
              "      <td>Brussels</td>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>India</th>\n",
              "      <td>New Delhi</td>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Brazil</th>\n",
              "      <td>Brasília</td>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "           Capital  Population\n",
              "Country                       \n",
              "Belgium   Brussels    11190846\n",
              "India    New Delhi  1303171035\n",
              "Brazil    Brasília   207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eHHIiKfqaIiB"
      },
      "source": [
        "하나의 인덱스만 가능한것은 아닙니다. DataFrame은 여러개의 인덱스를 가질 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-fQTkQ8haBj_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "827f13a4-129b-4c5e-89be-9989bcfe5340"
      },
      "source": [
        "df_index_with_country_and_capital = df.set_index(['Country', 'Capital'])\n",
        "\n",
        "df_index_with_country_and_capital"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th>Population</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Country</th>\n",
              "      <th>Capital</th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>Belgium</th>\n",
              "      <th>Brussels</th>\n",
              "      <td>11190846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>India</th>\n",
              "      <th>New Delhi</th>\n",
              "      <td>1303171035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Brazil</th>\n",
              "      <th>Brasília</th>\n",
              "      <td>207847528</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                   Population\n",
              "Country Capital              \n",
              "Belgium Brussels     11190846\n",
              "India   New Delhi  1303171035\n",
              "Brazil  Brasília    207847528"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TReiu48S4CF7"
      },
      "source": [
        "# 인덱싱\n",
        "df_index_with_country_and_capital.loc[['Belgium', 'Brusseles']]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NTH3IiH5x4WC"
      },
      "source": [
        "### Dataframe의 column은 어떤 데이터타입일까\n",
        "\n",
        "기존에 학습한 데이터프레임 생성 방식은 아래처럼 모든 데이터를 직접 명시해주는 것이었습니다.\n",
        "\n",
        "아래 코드는 각 열을 파이썬의 리스트 형태로 입력하는 방식입니다.\n",
        "리스트 형태로 입력된 데이터를 기반으로 판다스가 Series를 만들고 Series들로 DataFrame을 만드는 것이죠."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gbK4KNcUyO-A",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "ca4d78b1-ec04-40a0-91ac-f627069d2158"
      },
      "source": [
        "data = {'col1': [1, 2, 3, 4],\n",
        "        'col2': [5, 6, 7, 8],\n",
        "        'col3': [9, 10, 11, 12]}\n",
        "\n",
        "df_3 = pandas.DataFrame(data, \n",
        "                    index=['A', 'B', 'C', 'D'])\n",
        "\n",
        "df_3"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>col1</th>\n",
              "      <th>col2</th>\n",
              "      <th>col3</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>A</th>\n",
              "      <td>1</td>\n",
              "      <td>5</td>\n",
              "      <td>9</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>B</th>\n",
              "      <td>2</td>\n",
              "      <td>6</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>C</th>\n",
              "      <td>3</td>\n",
              "      <td>7</td>\n",
              "      <td>11</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>D</th>\n",
              "      <td>4</td>\n",
              "      <td>8</td>\n",
              "      <td>12</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   col1  col2  col3\n",
              "A     1     5     9\n",
              "B     2     6    10\n",
              "C     3     7    11\n",
              "D     4     8    12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wIASxZicuBM6"
      },
      "source": [
        "\n",
        "\n",
        "![](http://drive.google.com/uc?export=view&id=1vXLOGcypyLgT12DGNIGTnmna8BIW1pvK)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LwqNG8Vy1rcE"
      },
      "source": [
        "파이썬 리스트가 아닌 Series를 통해서도 DataFrame을 생성할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4QJnSeOKRCjY"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wsImXajZunqs",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 167
        },
        "outputId": "dd5d048f-5132-4fc3-f7ff-7a530ee92542"
      },
      "source": [
        "s_1 =pandas.Series([1, 2, 3, 4], index=['A', 'B', 'C', 'D'])\n",
        "s_2 = pandas.Series([5, 6, 7, 8], index=['A', 'B', 'C', 'D'])\n",
        "s_3 = pandas.Series([9, 10, 11, 12], index=['A', 'B', 'C', 'D'])\n",
        "\n",
        "data = {'col1': s_1,\n",
        "        'col2': s_2,\n",
        "        'col3': s_3}\n",
        "\n",
        "df_4 = pandas.DataFrame(data, index=['A', 'B', 'C', 'D'])\n",
        "\n",
        "df_4"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>col1</th>\n",
              "      <th>col2</th>\n",
              "      <th>col3</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>A</th>\n",
              "      <td>1</td>\n",
              "      <td>5</td>\n",
              "      <td>9</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>B</th>\n",
              "      <td>2</td>\n",
              "      <td>6</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>C</th>\n",
              "      <td>3</td>\n",
              "      <td>7</td>\n",
              "      <td>11</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>D</th>\n",
              "      <td>4</td>\n",
              "      <td>8</td>\n",
              "      <td>12</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   col1  col2  col3\n",
              "A     1     5     9\n",
              "B     2     6    10\n",
              "C     3     7    11\n",
              "D     4     8    12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jo2XT4f8a73H"
      },
      "source": [
        "## NumPy ndarray와 비교"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0iyjucgZbRls"
      },
      "source": [
        "### 공통점\n",
        "\n",
        "NumPy 다차원배열처럼 많은 연산들이 요소들간에 이루어집니다.(Elementwise-operation)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aNNINWrdbdO5"
      },
      "source": [
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sso4sI80bgME"
      },
      "source": [
        "s + 10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "19nHeT3hb6-Y"
      },
      "source": [
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s_AleGwpbih2"
      },
      "source": [
        "df['Population'] / 1000"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-3ylexJb9h6"
      },
      "source": [
        "df['Country'] + df['Capital']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlzyAgCZbSst"
      },
      "source": [
        "### 차이점\n",
        "\n",
        "Series간 연산을 하는 경우, index를 기반으로 이루어집니다. \n",
        "\n",
        "(모든 NumPy 다차원배열은 shape가 동일하다면 index도 동일하기에 index가 달라 연산이 이루어지지 않는 경우는 없음.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DVDH0OsucHb3"
      },
      "source": [
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o5eN9gnbcJLd"
      },
      "source": [
        "s1 = s[['a', 'b']]\n",
        "s2 = s[['b', 'c']]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7XS0v9FPcIqM"
      },
      "source": [
        "s1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W7yZcyV9cUV0"
      },
      "source": [
        "s2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7OHKXm9scUSa"
      },
      "source": [
        "s1 + s2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Do8I5trIzsxo"
      },
      "source": [
        "## 실습"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sk6FDoAozxv6"
      },
      "source": [
        "df_index_with_country"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fCOg8j6nzvYd"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: df_index_with_country이 데이터로 주어졌을때 각 국가의 수도 인구는 벨기에 수도 인구 대비 몇 배인지 구하세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XoHaynG60L1L"
      },
      "source": [
        "df_index_with_country[?] / df_index_with_country[?][?]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lMeyci4y7l9v"
      },
      "source": [
        "# 3. Pandas Importing/Exproting\n",
        "\n",
        "직접 데이터를 입력하여 DataFrame이나 Series를 생성할 일은 실무에서 많지 않습니다.<br>\n",
        "실무에서는 이미 데이터가 존재하는 경우가 많고 그 데이터를 판다스로 importing해서 분석을 진행합니다.\n",
        "\n",
        "CSV나 엑셀 형태의 파일로 저장된 데이터를 판다스로 가져오거나 직접 데이터베이스에 연결해서 데이터를 가져와서 작업하는 경우가 일반적입니다.\n",
        "\n",
        "pandas가 지원하는 Importing/Exporting 포맷은 아래와 같습니다.\n",
        "- csv (모든 text파일 연결에 사용)\n",
        "- excel\n",
        "- sql (모든 데이터베이스 연결에 사용)\n",
        "- hdf5\n",
        "- json\n",
        "- html\n",
        "- pickle\n",
        "- ..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zuWUpYF2dbJv"
      },
      "source": [
        "Importing 함수의 경우 **pd.read** 형태를 가지며 Exporting 함수의 경우 **df.to** 형태를 가집니다.\n",
        "\n",
        "\n",
        "예시) json의 경우"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EMZbcUmXd-ul"
      },
      "source": [
        "json_data = df.to_json()\n",
        "json_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xHQAhb2jeNoq"
      },
      "source": [
        "pd.read_json(json_data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "645kKNXhf3U7"
      },
      "source": [
        "## 1) CSV\n",
        "\n",
        "하나의 파일로 관리 가능한 크기의 데이터라면, 데이터를 파일로 저장할때 일반적으로 CSV포맷을 활용합니다.\n",
        "\n",
        "CSV는 comma-separated values의 약자이며 값들을 ,로 구분합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DdFs7FPCf6Wc"
      },
      "source": [
        "### Importing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7_FfXUw5z5yz"
      },
      "source": [
        "# 파일다운로드 받기\n",
        "!wget -O 'iris_sample.csv' https://raw.githubusercontent.com/duc-ke/edu_jupyter_pandas/master/dataset/iris_sample.csv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bx58Zcp8TPuJ"
      },
      "source": [
        "df_iris_sample = pd.read_csv('iris_sample.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pJs1yxi8UQ7b"
      },
      "source": [
        "df_iris_sample"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1GSSEjj8Y2te"
      },
      "source": [
        "csv뿐만 아니라 tsv, txt도 read_csv()파일을 통해 읽어올 수 있습니다.\n",
        "\n",
        "파일 관점에서 보면 csv, tsv, txt는 동일합니다. csv, tsv역시 txt파일이며 값을 구분하는 구분자가 콤마냐 탭이냐의 차이입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1kwwPCibZpJU"
      },
      "source": [
        "#### txt"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ou1Gp4MRY3MN"
      },
      "source": [
        "# 'iris_sample.txt' 로 확장자를 바꿔 파일다운로드 받기\n",
        "!wget -O 'iris_sample.txt' https://raw.githubusercontent.com/duc-ke/edu_jupyter_pandas/master/dataset/iris_sample.csv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VoTlAO0AZAfJ"
      },
      "source": [
        "pd.read_csv('iris_sample.txt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uh8sWiisZq2Y"
      },
      "source": [
        "#### tsv\n",
        "\n",
        "TSV는 tab-separated values의 약자이며 값들을 tab으로 구분합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c4RCDKf1Zthi"
      },
      "source": [
        "!wget -O 'tsv_sample.tsv' https://gist.githubusercontent.com/mbostock/3305937/raw/a5be7c5fd55c4fa0ca8a400cb68d658a40989966/data.tsv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3fAObB4QafeG"
      },
      "source": [
        "pd.read_csv('tsv_sample.tsv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cgSUF8mSafTS"
      },
      "source": [
        "pd.read_csv('tsv_sample.tsv', sep='\\t')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qm-z0tyjVQ89"
      },
      "source": [
        "# 새출발"
      ],
      "execution_count": 102,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rbFETnQgVUaJ",
        "outputId": "5202f56f-c8d2-450d-ccf3-51bb5d0c4039"
      },
      "source": [
        "!ls -l"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "total 16\n",
            "drwxr-xr-x 1 root root 4096 May  6 13:44 sample_data\n",
            "-rw-r--r-- 1 root root 9729 Jun  2 06:11 tips.csv\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G0CyralGYr6B"
      },
      "source": [
        "!pip install pandas-profiling==2.11.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H7Da_CWoWsRy"
      },
      "source": [
        "import pandas as pd"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yg4jSsGyY564"
      },
      "source": [
        "import pandas_profiling"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "id": "h4fZ-KJTcfUe",
        "outputId": "5df763d4-4827-44e3-e68b-ed2c6103c96a"
      },
      "source": [
        "df.describe()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>total_bill</th>\n",
              "      <th>tip</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>244.000000</td>\n",
              "      <td>244.000000</td>\n",
              "      <td>244.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>19.785943</td>\n",
              "      <td>2.998279</td>\n",
              "      <td>2.569672</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>8.902412</td>\n",
              "      <td>1.383638</td>\n",
              "      <td>0.951100</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>3.070000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>13.347500</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>17.795000</td>\n",
              "      <td>2.900000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>24.127500</td>\n",
              "      <td>3.562500</td>\n",
              "      <td>3.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>50.810000</td>\n",
              "      <td>10.000000</td>\n",
              "      <td>6.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       total_bill         tip        size\n",
              "count  244.000000  244.000000  244.000000\n",
              "mean    19.785943    2.998279    2.569672\n",
              "std      8.902412    1.383638    0.951100\n",
              "min      3.070000    1.000000    1.000000\n",
              "25%     13.347500    2.000000    2.000000\n",
              "50%     17.795000    2.900000    2.000000\n",
              "75%     24.127500    3.562500    3.000000\n",
              "max     50.810000   10.000000    6.000000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "auIzurB1WZI0"
      },
      "source": [
        "df = pd.read_csv('./tips.csv')"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gh8izeUablyj"
      },
      "source": [
        "df.profile_report()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "0a04Nns6ajEL",
        "outputId": "7f250046-88c0-4a94-a41f-d42242cbc4ff"
      },
      "source": [
        "pd.__version__"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1.1.5'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vUMsET9sZFoo"
      },
      "source": [
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "id": "uLsUUc_XW29F",
        "outputId": "99d507ea-9fb4-4bef-e8d6-21be7122063b"
      },
      "source": [
        "df.describe()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>total_bill</th>\n",
              "      <th>tip</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>244.000000</td>\n",
              "      <td>244.000000</td>\n",
              "      <td>244.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>19.785943</td>\n",
              "      <td>2.998279</td>\n",
              "      <td>2.569672</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>8.902412</td>\n",
              "      <td>1.383638</td>\n",
              "      <td>0.951100</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>3.070000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>13.347500</td>\n",
              "      <td>2.000000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>17.795000</td>\n",
              "      <td>2.900000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>24.127500</td>\n",
              "      <td>3.562500</td>\n",
              "      <td>3.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>50.810000</td>\n",
              "      <td>10.000000</td>\n",
              "      <td>6.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       total_bill         tip        size\n",
              "count  244.000000  244.000000  244.000000\n",
              "mean    19.785943    2.998279    2.569672\n",
              "std      8.902412    1.383638    0.951100\n",
              "min      3.070000    1.000000    1.000000\n",
              "25%     13.347500    2.000000    2.000000\n",
              "50%     17.795000    2.900000    2.000000\n",
              "75%     24.127500    3.562500    3.000000\n",
              "max     50.810000   10.000000    6.000000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IwuFGzCWXEp7",
        "outputId": "db355274-ae7d-4439-bdfb-ff9a4b39dff5"
      },
      "source": [
        "df.info()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 244 entries, 0 to 243\n",
            "Data columns (total 7 columns):\n",
            " #   Column      Non-Null Count  Dtype  \n",
            "---  ------      --------------  -----  \n",
            " 0   total_bill  244 non-null    float64\n",
            " 1   tip         244 non-null    float64\n",
            " 2   sex         244 non-null    object \n",
            " 3   smoker      244 non-null    object \n",
            " 4   day         244 non-null    object \n",
            " 5   time        244 non-null    object \n",
            " 6   size        244 non-null    int64  \n",
            "dtypes: float64(2), int64(1), object(4)\n",
            "memory usage: 13.5+ KB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QIGIw8aMXUUP",
        "outputId": "88e11f44-7dfe-4b4a-eed4-a062fa7c853d"
      },
      "source": [
        "df.columns"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['total_bill', 'tip', 'sex', 'smoker', 'day', 'time', 'size'], dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 415
        },
        "id": "aPkseq98Xdek",
        "outputId": "95fc6007-c207-4a9a-9719-9db109316639"
      },
      "source": [
        "df"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>total_bill</th>\n",
              "      <th>tip</th>\n",
              "      <th>sex</th>\n",
              "      <th>smoker</th>\n",
              "      <th>day</th>\n",
              "      <th>time</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>16.99</td>\n",
              "      <td>1.01</td>\n",
              "      <td>Female</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>10.34</td>\n",
              "      <td>1.66</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>21.01</td>\n",
              "      <td>3.50</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>23.68</td>\n",
              "      <td>3.31</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>24.59</td>\n",
              "      <td>3.61</td>\n",
              "      <td>Female</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>239</th>\n",
              "      <td>29.03</td>\n",
              "      <td>5.92</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sat</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>240</th>\n",
              "      <td>27.18</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Sat</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>241</th>\n",
              "      <td>22.67</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Sat</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>242</th>\n",
              "      <td>17.82</td>\n",
              "      <td>1.75</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sat</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>243</th>\n",
              "      <td>18.78</td>\n",
              "      <td>3.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>No</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>244 rows × 7 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     total_bill   tip     sex smoker   day    time  size\n",
              "0         16.99  1.01  Female     No   Sun  Dinner     2\n",
              "1         10.34  1.66    Male     No   Sun  Dinner     3\n",
              "2         21.01  3.50    Male     No   Sun  Dinner     3\n",
              "3         23.68  3.31    Male     No   Sun  Dinner     2\n",
              "4         24.59  3.61  Female     No   Sun  Dinner     4\n",
              "..          ...   ...     ...    ...   ...     ...   ...\n",
              "239       29.03  5.92    Male     No   Sat  Dinner     3\n",
              "240       27.18  2.00  Female    Yes   Sat  Dinner     2\n",
              "241       22.67  2.00    Male    Yes   Sat  Dinner     2\n",
              "242       17.82  1.75    Male     No   Sat  Dinner     2\n",
              "243       18.78  3.00  Female     No  Thur  Dinner     2\n",
              "\n",
              "[244 rows x 7 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ocxS1eGeXlIi"
      },
      "source": [
        "### Exporting\n",
        "csv를 통해 생성한 df_iris_sample에서 첫 5행만 'iris_sample_2.csv'로 저장해봅시다"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tgt6e9S-XysT"
      },
      "source": [
        "df_iris_sample.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BBXNvVSXgCR"
      },
      "source": [
        "df_iris_sample_2 = df_iris_sample.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uk-39yFBYO6V"
      },
      "source": [
        "df_iris_sample_2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hm092WujYP_-"
      },
      "source": [
        "df_iris_sample_2.to_csv('iris_sample_2.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Neo2qDkTYXQS"
      },
      "source": [
        "잘 저장되었는지 다시 확인해보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QOSCOkw9YSzS"
      },
      "source": [
        "pd.read_csv('iris_sample_2.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_UgpOYJaYmRD"
      },
      "source": [
        "**Unnamed: 0** 라는 열이 들어가 있습니다. 이는 to_csv()시 index도 함께 파일에 저장되기에 생기는 문제입니다.\n",
        "\n",
        "저장시 index=False 를 통해 이 문제를 해결할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eSLGS_a_Yces"
      },
      "source": [
        "df_iris_sample_2.to_csv('iris_sample_2_no_index.csv', index=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BPDXvSSCbNty"
      },
      "source": [
        "pd.read_csv('iris_sample_2_no_index.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xXcD1LGSf_te"
      },
      "source": [
        "txt, tsv도 동일한 to_csv()로 다룰 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g-03_vB6fg-5"
      },
      "source": [
        "## 2) 엑셀\n",
        "\n",
        "엑셀파일은 read_excel(), to_excel() 을 활용해서 다룹니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o0OV3clFgFKb"
      },
      "source": [
        "### 입력"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pp5x85GybPqj"
      },
      "source": [
        "# 파일다운로드 받기\n",
        "!wget -O '성적표.xlsx' https://www.dropbox.com/s/zubhmxf4aj9eg7y/%EC%84%B1%EC%A0%81%ED%91%9C.xlsx?dl=0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s2FkttfjgVCd"
      },
      "source": [
        "pd.read_excel('성적표.xlsx')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yld23AfZsVyg"
      },
      "source": [
        "기본적으로 read_excel()은 첫번째 시트를 가져옵니다. 위 코드는 sheet_name=0이 생략되어있으며 아래의 코드와 동일한 결과를 보입니다. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-oK6akytsO8J"
      },
      "source": [
        "pd.read_excel('성적표.xlsx', sheet_name=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fQSW5lB3sfKc"
      },
      "source": [
        "두 번째 시트를 가져오려면 sheet_name 파라메터에 1을 전달해야 합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O9RemV47sk3W"
      },
      "source": [
        "pd.read_excel('성적표.xlsx', sheet_name=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s4dbCdVcsnl-"
      },
      "source": [
        "또는 시트의 이름을 명시해서 가져올수도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PPhGh3z4gbAW"
      },
      "source": [
        "pd.read_excel('성적표.xlsx', sheet_name='Sheet2')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N_drj7GggGpC"
      },
      "source": [
        "### 출력"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avfxaDS_s25y"
      },
      "source": [
        "to_excel()로 엑셀 파일 쓰기가 가능합니다.\n",
        "\n",
        "sheet_name 파라메터를 통해 시트명을 정할 수 있습니다.\n",
        "\n",
        "> to_excel()을 사용하기 위해선 ‘openpyxl’ 또는 ‘xlsxwriter’ 라이브러리가 필요합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WyUMAjavta9o"
      },
      "source": [
        "# xlsxwriter 라이브러리 설치\n",
        "!pip install xlsxwriter"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "khKOIgArgHGN"
      },
      "source": [
        "df_sheet2 = pd.read_excel('성적표.xlsx', sheet_name='Sheet2')\n",
        "\n",
        "df_sheet2.to_excel('to_excel.xlsx', sheet_name='이름을 적어주세요')\n",
        "# df_sheet2.to_excel('to_excel.xlsx', sheet_name='이름을 적어주세요', index=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R24J-mp9hS2i"
      },
      "source": [
        "pd.read_excel('to_excel.xlsx')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQ121Aq9IrxW"
      },
      "source": [
        "## 3) 데이터베이스"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cvN2cphNH70V"
      },
      "source": [
        "#  라이브러리 설치\n",
        "!pip install mysql-connector-python"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXghBj6LIzdk"
      },
      "source": [
        "import sqlalchemy\n",
        "\n",
        "user = \"anonymous\"\n",
        "host = \"ensembldb.ensembl.org\"\n",
        "port = 3337\n",
        "database = \"ailuropoda_melanoleuca_core_79_1\"\n",
        "\n",
        "url = f\"mysql+mysqlconnector://{user}@{host}:{port}/{database}\"\n",
        "# url = f\"mysql+mysqlconnector://{user}:{password}@{host}:{port}/{database}\"\n",
        "\n",
        "connection = sqlalchemy.create_engine(url)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LKispu2iI2CS"
      },
      "source": [
        "pd.read_sql(\"select * from analysis limit 10\", connection)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QwBNMLnavK0F"
      },
      "source": [
        "# 4. 인덱싱/슬라이싱\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hdkJcRl2ggbu"
      },
      "source": [
        "## 0) [ ] \n",
        "\n",
        "- **[ ]** 연산자를 활용해 데이터를 가져올 수 있습니다.\n",
        "- 간단히 사용하기에는 좋지만 불규칙적이라 loc, iloc를 통한 인덱싱/슬라이싱을 추천합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "konD4Inigjzw"
      },
      "source": [
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "InL7DbCPgoSK"
      },
      "source": [
        "- 단일 칼럼 조회"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_5pql3ZVgl4-"
      },
      "source": [
        "df['Country']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M4qdK7lNgrSW"
      },
      "source": [
        "- 복수 칼럼 조회"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pZSHpQiYgsS2"
      },
      "source": [
        "df[['Country', 'Population']]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SIJHWDJggziN"
      },
      "source": [
        "- 슬라이싱\n",
        "  - **[ ]** 를 통한 슬라이싱은 row(행)에 적용됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PNskjZYZgr0X"
      },
      "source": [
        "# index 슬라이싱. 2 미포함\n",
        "df[0:2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Uv0ciZ9hxqA"
      },
      "source": [
        "- 슬라이싱\n",
        "  - index로 슬라이싱 하지 않고 label로 슬라이싱 하는 경우, 마지막 라벨은 포함됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G7uPuFNfhsre"
      },
      "source": [
        "data = {'Country': ['Belgium', 'India', 'Brazil'],\n",
        "        'Capital': ['Brussels', 'New Delhi', 'Brasília'],\n",
        "        'Population': [11190846, 1303171035, 207847528]}\n",
        "\n",
        "df_2 = pd.DataFrame(data\n",
        "                  , index=['aa', 'bb', 'cc']                  \n",
        "                 )\n",
        "\n",
        "df_2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jcd0_N5ahuFR"
      },
      "source": [
        "# label 슬라이싱. 'cc' 포함\n",
        "df_2['aa':'cc']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VYysdk6hvMGO"
      },
      "source": [
        "## 1) 인덱싱\n",
        "\n",
        "- loc (Label based indexing)\n",
        "- iloc (Positional indexing)\n",
        "- ix (사용 권장하지 않음)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xSB-KJbowIsy"
      },
      "source": [
        "df.iloc[0,0] # 위치를 통한 인덱싱"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3i2yQzSFwPgp"
      },
      "source": [
        "df.iat[0,0] # 위치를 통한 인덱싱"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KKle-rq4wPd9"
      },
      "source": [
        "df.loc[0, 'Country'] # 라벨을 통한 인덱싱"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RHFmAXn1wPbP"
      },
      "source": [
        "df.at[0, 'Country'] # 라벨을 통한 인덱싱"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iTZvdpcywPYk"
      },
      "source": [
        "df.ix[1, 'Capital'] # 위치/라벨을 통한 인덱싱 (사용하지 말것을 권장)\n",
        "                    # 행은 위치, 열은 라벨을 통해 인덱싱"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L3Z0O-wKvNPT"
      },
      "source": [
        "## 2) 슬라이싱"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hdofFctTwT_3"
      },
      "source": [
        "df.iloc[0:1,0:2] # 위치를 통한 슬라이싱 (끝은 미포함)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A0e1013MwT6d"
      },
      "source": [
        "df.loc[0:1, 'Country':'Capital'] # 라벨을 통한 슬라이싱 (끝 포함)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxOlwh3XvPM1"
      },
      "source": [
        "## 3) 불리언 인덱싱 (필터링)\n",
        "- 조건을 제시하고 조건이 True인 요소만을 조회하는 방식\n",
        "- 필터링이라고도 불리웁니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1xI6_LdhwYgw"
      },
      "source": [
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FaI-4-5JwZvj"
      },
      "source": [
        "df['Population'] > 200000000"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rwdRR5QpwcXP"
      },
      "source": [
        "df[df['Population'] > 200000000] "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ht4SZP9r1SId"
      },
      "source": [
        "## 실습"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z_0-TueP1TG_"
      },
      "source": [
        "# dataframe\n",
        "data = {'country': ['Belgium', 'France', 'Germany', 'Netherlands', 'United Kingdom'],\n",
        "        'population': [11.3, 64.3, 81.3, 16.9, 64.9],\n",
        "        'area': [30510, 671308, 357050, 41526, 244820],\n",
        "        'capital': ['Brussels', 'Paris', 'Berlin', 'Amsterdam', 'London']}\n",
        "countries = pd.DataFrame(data)\n",
        "countries = countries.set_index('country') # 인덱스 지정\n",
        "countries"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6SznKDyR1k7R"
      },
      "source": [
        "---\n",
        "\n",
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 인구밀도를 의미하는 `density` 칼럼을 추가하세요. (주의: 현재 'population' 칼럼은 10만 단위로 표기되어 있습니다)  \n",
        "  \n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-OlQOEiN144s"
      },
      "source": [
        "countries['density'] = countries[?]*1000000 / countries[?]\n",
        "countries"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bqITcsFi18mG"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 인구밀도가 300을 초과하는 국가(country)의 수도(capital)과 인구(population)을 선택해주세요.  \n",
        "  \n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mBbhH1xf19Ev"
      },
      "source": [
        "countries.loc[countries[?] > 300, [?]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XPGBIDXT2TL7"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 'density_ratio' 칼럼을 추가해주세요. (density_ratio = 인구밀도/평균 인구밀도)\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5YqWGkoo2S0C"
      },
      "source": [
        "countries['density_ratio'] = \n",
        "countries"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qehg-_vu2i3U"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 영국(United Kingdom)의 수도(capital)를 'Cambridge'로 변경해주세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zDjD-qnw2jS5"
      },
      "source": [
        "countries.loc[?, ?] = 'Cambridge'\n",
        "countries"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AffG6gW021ru"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 인구 밀도가 100 초과, 300 미만인 국가들을 표시해주세요.  \n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qfeknDLB22U3"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zY2tEY6Ol1LN"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XTDQx7-XLnH7"
      },
      "source": [
        "- 스트링 다루는 법"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xpwX7RBvmFRc"
      },
      "source": [
        "countries['capital'].str.len()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XTz_7CPwl1iQ"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zuaQGg6ukTUs"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 수도가 7글자 이상인 국가들을 표시해주세요. (힌트: string의 len( )를 사용하세요.)\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_lMYHULGkWqT"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6oYKCYktkY6U"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 수도에 'am' 이 포함되는 국가들을 표시해주세요. (힌트: string의 contains( )를 사용하세요.)\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eTdOWVp7kag4"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "edNt-GSWjtif"
      },
      "source": [
        "# 5. 삭제"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-zkvEE0vRU9"
      },
      "source": [
        "## 1) Row(행) 삭제\n",
        "\n",
        "\n",
        "- axis=0\n",
        "- axis의 기본 값이 0이니 생략 가능"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yMsi3RVHvRSa"
      },
      "source": [
        "### 단일 행 삭제"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SsK2d2WQw8aR"
      },
      "source": [
        "df.drop(1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1zgd5gTrvRPz"
      },
      "source": [
        "### 복수 행 삭제"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "25VYZLmHw-hI"
      },
      "source": [
        "df.drop([0,1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vDTXYysvRNJ"
      },
      "source": [
        "## 2) Column(열) 삭제\n",
        "\n",
        "- axis=1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hhT8jOZBvREm"
      },
      "source": [
        "### 단일 열 삭제"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MsmBlJGJxBtz"
      },
      "source": [
        "df.drop('Country', axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eK8S43T6vsLc"
      },
      "source": [
        "### 복수 열 삭제"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CGZD7ZK6xCop"
      },
      "source": [
        "df.drop(['Country', 'Population'], axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DASrakJWvsJG"
      },
      "source": [
        "## 참조. Series 삭제"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AbZ1jPAQj8l8"
      },
      "source": [
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1aJ4d_4PxDwU"
      },
      "source": [
        "s.drop(['a', 'c'])\n",
        "# s = s.drop(['a', 'c']) # 삭제한 결과를 사용하고 싶다면 다시 변수로 선언해주어야 한다"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "abgLjKyoj0dF"
      },
      "source": [
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j5VpMhKHvsGT"
      },
      "source": [
        "# 6. Pandas 함수"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jyYhtTPexTyi"
      },
      "source": [
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UBDrf9t1n946"
      },
      "source": [
        "##  데이터 탐색에 유용한 함수"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-wI1yFMfxTmH"
      },
      "source": [
        "df.describe() # 숫자 열에만 적용. 숫자열의 통계값과 최대최소값등을 보여줌"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3zttj97FnVEc"
      },
      "source": [
        "df.head(2) # 초반 n행을 보여줌. default는 5\n",
        "# df.head(n=2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zmzUTnvzpEW3"
      },
      "source": [
        "df.sort_values('Population') # 오름차순 정렬"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I5iDixxGpYVm"
      },
      "source": [
        "df.sort_values('Population', ascending=False) # 내림차순 정렬"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CQOj1KgCpxjD"
      },
      "source": [
        "df.isnull() # null값이 있는지 확인"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VQ5JcBxup9CK"
      },
      "source": [
        "# column(열)별로 null값이 있는지 확인\n",
        "df.isnull().any() # axis=0이 생략된 형태\n",
        "# df.isnull().any(axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0K9YoRRTqQ5G"
      },
      "source": [
        "# row(행)별로 null값이 있는지 확인\n",
        "df.isnull().any(axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rrGSHnCTrijK"
      },
      "source": [
        "# null값이 DataFrame내에 하나라도 있는지 확인\n",
        "df.isnull().any().any()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m108eaDWDPzw"
      },
      "source": [
        "df2 = df.copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d99-rLruDSHC"
      },
      "source": [
        "df2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dnud_my4Da9L"
      },
      "source": [
        "df2.loc[0, 'Population'] = None"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sZa1Mx4ZDgUP"
      },
      "source": [
        "df2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZGeyq9kSDkp9"
      },
      "source": [
        "df2.isnull().any()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4p6mLrynn11C"
      },
      "source": [
        "## aggregate 함수"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tlLg0TJ7xQsL"
      },
      "source": [
        "df.count()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "czXuQWy7xTvF"
      },
      "source": [
        "df.sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VpH-9bqVxTr-"
      },
      "source": [
        "df.min()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DtS1jUIXxTo6"
      },
      "source": [
        "df.max()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B7Xm-6vexTjS"
      },
      "source": [
        "df.mean() # 숫자 열에만 적용"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qB5keamKxTgG"
      },
      "source": [
        "df.median() # 숫자 열에만 적용"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fz6LzszIpkqw"
      },
      "source": [
        "## 실습"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wPZtCT9ntSPh"
      },
      "source": [
        "!wget -O 'titles.csv' https://docs.google.com/spreadsheets/d/1fiioUPMRurfE523yWGaRF3ckO-TUHu1AaIAI6Eo7Ti8/export?format=csv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WxKnfG_gthPz"
      },
      "source": [
        "titles = pd.read_csv('titles.csv')\n",
        "titles.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dVuuo1i2t7db"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: titles 데이터프레임에는 몇 개의 영화가 기록되어 있나요?\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FAIaWolpuCgp"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VKqeNALFt7So"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: titles에서 가장 빠른 시기에 제작된 영화 두 개를 표시하세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "atYpzTLVu-iQ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tmubd6MHvBm6"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 제목(title)이 \"Hamlet\"인 영화는 몇 개가 있나요?\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nY2w0m1ouFSV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Flu72UB2uHU3"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 제목(title)이 \"Treasure Island\"인 영화를 제작년도(year)의 오름차순에 따라 표시하세요. (df.sort_values())\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dV90ztSTuIuT"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xzv9S4B8uNNc"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 1590년에서 1959년 사이 몇 개의 영화가 만들어졌나요?(1950 <= 제작년도 <= 1959)\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "929NCyFBuP6V"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7jrPWSiDvxvM"
      },
      "source": [
        "# 7. apply 함수\n",
        "\n",
        "- apply함수는 요소별로 적용됨"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WpEUE2Ndvxtc"
      },
      "source": [
        "## 하나의 요소를 활용하는 경우"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u2vkhvJpxcKF"
      },
      "source": [
        "df.loc[:, 'Population':'Population']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yp-6dNfDxfLW"
      },
      "source": [
        "- 각 Population에 1씩 추가"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KgLRd--nxd7z"
      },
      "source": [
        "df.loc[:, 'Population':'Population'].apply(lambda x: x + 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zwSZ_yfqvxqu"
      },
      "source": [
        "## 여러개의 요소를 활용하는 경우"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jwQLS3NwxkBF"
      },
      "source": [
        "df.loc[:, 'Country':'Capital']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mz5pHeH5xrIa"
      },
      "source": [
        "칼럼명(Country, Capital)을 사용해도 되고 칼럼 위치(0, 1)를 사용해도 됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5gai9cLaxm_V"
      },
      "source": [
        "df.loc[:, 'Country':'Capital'].apply(lambda x: x['Country'] + \"'s capital is \" + x['Capital'], axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bc4kEaKMxl4Q"
      },
      "source": [
        "df.loc[:, 'Country':'Capital'].apply(lambda x: x[0] + \"'s capital is \" + x[1], axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XegFt123tJrR"
      },
      "source": [
        "# 8. GroupBy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KM59wHpotpeX"
      },
      "source": [
        "dataframe을 key값에 따라 나눈 뒤 각각에 특정한 함수를 적용한 뒤 다시 합치고 싶을때 사용합니다.\n",
        "\n",
        "groupby는 Split-Apply-Combine 단계를 거칩니다.\n",
        "\n",
        "- **Split**: Key값에 따라 나눈 뒤\n",
        "- **Apply**: 함수를 적용\n",
        "- **Combine**: 다시 합치기\n",
        "\n",
        "\n",
        "SQL의 **GROUP BY**와 유사합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "41PEjkBrtTHZ"
      },
      "source": [
        "![alt text](https://github.com/jorisvandenbossche/pandas-tutorial/blob/master/img/splitApplyCombine.png?raw=true)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KsoNGg6LuopT"
      },
      "source": [
        "아래 데이터로 Groupby 예를 들어 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5-hMQ1CwtJJe"
      },
      "source": [
        "df = pd.DataFrame({'key':['A','B','C','A','B','C','A','B','C'],\n",
        "                   'data': [0, 5, 10, 5, 10, 15, 10, 15, 20]})\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l_1Np7byumvr"
      },
      "source": [
        "key값에 따라 data의 합을 구하고 싶다면 어떻게 해야 할까요?\n",
        "\n",
        "key값대로 불리언인덱싱을 한 후 sum()함수를 취해주면 됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ASPS5_nKuwNp"
      },
      "source": [
        "df['key'].unique()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wQShoJgVu8ta"
      },
      "source": [
        "key는 'A', 'B', 'C' 이렇게 세 개가 있고 각각의 키값에 대해 불리언 인덱싱을 한 후 sum()해보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i85WituUuU_e"
      },
      "source": [
        "df[df['key'] == \"A\"].sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h0FIs2I5udAn"
      },
      "source": [
        "df[df['key'] == \"B\"].sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wW7eiYvkuhF2"
      },
      "source": [
        "df[df['key'] == \"C\"].sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rsI1qgPfvETm"
      },
      "source": [
        "이 과정을 groupby를 사용하면 한번에 수행할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UlFzm2vruilS"
      },
      "source": [
        "df.groupby('key').sum()\n",
        "# df.groupby('key').aggregate(np.sum)  # 'sum'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0B-YnD_svWFZ"
      },
      "source": [
        "## 실습"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Wy6SdnfvJVf"
      },
      "source": [
        "df = pd.read_csv('https://raw.githubusercontent.com/jorisvandenbossche/pandas-tutorial/master/data/titanic.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Fo8R8J-vLJT"
      },
      "source": [
        "df.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lFdZ25VqwMQ_"
      },
      "source": [
        "타이타닉 데이터셋을 df라는 판다스 데이터프레임으로 불러왔습니다. 이 데이터로 아래 실습을 진행해주세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ldLQf18gwCsV"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: groupby()를 사용하여 각 성별(sex)의 평균 나이(age)를 구하세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uzFJ8ZOvwC4F"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kNS2xisOwUc7"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 전체 승객(passenger)의 평균 생존율을 구하세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QnFOw1xlwJro"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rk69GUpOwWXO"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 25세 이하 승객의 생존율을 구하세요. (힌트: 불리언 인덱싱)\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ebd0k35LwYt9"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0mXpGeDJwWVG"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 남성의 생존율을 구하세요. 여성의 생존율을 구하세요. (힌트: 불리언 인덱싱)\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nnCfAQcCxF8X"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-giWLt_xtHN"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 생존율을 구하는 함수가 작성되어 있습니다. 성별 생존율을 groupby를 활용해 구하기 위해 ?부분을 알맞게 채워주세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "louE30KJwcYw"
      },
      "source": [
        "def survival_ratio(survived):\n",
        "    return survived.sum() / len(survived)\n",
        "  \n",
        "df.groupby(?)[?].aggregate(survival_ratio)  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dO4sA6wXwWQW"
      },
      "source": [
        "<div class=\"alert alert-success\">\n",
        "    <b>EXERCISE</b>: 'Pclass'별로 생존율을 보기 위해 bar 차트를 그리고자 합니다. ?부분을 알맞게 채워서 bar 차트를 그려주세요.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bZVSD5w0wgv3"
      },
      "source": [
        "df.groupby(?)[?].aggregate(survival_ratio).plot(kind='bar')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}