0_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/0_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": null,
      "outputs": []
    },
    {
      "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": null,
      "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": "doteWblhtMxj"
      },
      "source": [
        "s = pd.Series([3, -5, 7, 4]) # 인덱스 없이 생성"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Msp-X6nixlnY"
      },
      "source": [
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SRc6GQUKU64O"
      },
      "source": [
        "인덱스를 특별히 지정해주지 않으면 NumPy 다차원배열처럼 0부터 인덱스가 시작됩니다.\n",
        "\n",
        "NumPy 다차원 배열과 다르게 Pandas Series는 인덱스를 지정해 줄 수 있으며 숫자가 아닌 문자열도 인덱스가 될 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3nUYDZ3gU7X_"
      },
      "source": [
        "s = pd.Series([3, -5, 7, 4], index=['a', 'b', 'c', 'd'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KokRyLH9U7yd"
      },
      "source": [
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G88ENaia4xvy"
      },
      "source": [
        "**type()**을 통해 데이터타입이 Series인 걸 확인할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a4cGRxYi1KX5"
      },
      "source": [
        "type(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhuUWc2ZYEO5"
      },
      "source": [
        "### 속성"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "24tY76qdTh1S"
      },
      "source": [
        "Series는 index와 values를 가집니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mNOuTlUKTkrJ"
      },
      "source": [
        "s.index"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QOpkc9SATknp"
      },
      "source": [
        "s.values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "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 = pd.Series(pop_dict)\n",
        "population"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eMr79qK7V2O7"
      },
      "source": [
        "딕셔너리에서 key값을 이용해 value를 조회하듯 Series에서 index를 이용해 value를 조회할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9I1TeWdVWMYY"
      },
      "source": [
        "pop_dict['France']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6aKhymr5zerK"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "st0IKIMzV5IX"
      },
      "source": [
        "population['France']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AzyUebKvWC2J"
      },
      "source": [
        "딕셔너리와 Series의 차이점은, 딕셔너리의 Key는 순서가 없고 pandas Series의 index는 순서가 있다는 점입니다.\n",
        "그렇기에 Series는 index의 순서를 통해서도 value 조회가 가능합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mmq8pkx9WYie"
      },
      "source": [
        "# KeyError 발생(2라는 Key 값은 없음)\n",
        "pop_dict[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R6dTfwFsWVuD"
      },
      "source": [
        "population[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLs-gxb9WrQg"
      },
      "source": [
        "또한 Series는 딕셔너리와 다르게 아래와 같은 연산이 가능합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C5_h-zgDVoQ7"
      },
      "source": [
        "population*1000"
      ],
      "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": "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_"
      },
      "source": [
        "# 중첩된 리스트를 통한 데이터 생성\n",
        "# 각 행을 리스트로 만들어야 함\n",
        "data = [['Belgium', 'Brussels', 11190846],\n",
        "        ['India', 'New Delhi', 1303171035],\n",
        "        ['Brazil', 'Brasília', 207847528]]\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T26fEspK6bfp"
      },
      "source": [
        "columns 파라메터를 통해 칼럼명 역시 정해줄 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jdb1iQCU6VEM"
      },
      "source": [
        "# 중첩된 리스트를 통한 데이터 생성\n",
        "# 각 행을 리스트로 만들어야 함\n",
        "data = [['Belgium', 'Brussels', 11190846],\n",
        "        ['India', 'New Delhi', 1303171035],\n",
        "        ['Brazil', 'Brasília', 207847528]]\n",
        "\n",
        "df = pd.DataFrame(data, columns=['Country', 'Capital', 'Population'])\n",
        "\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cytnMis_5o6z"
      },
      "source": [
        "데이터프레임의 데이터는 딕셔너리로 넘겨주는게 일반적입니다.\n",
        "\n",
        "- 칼럼명을 함께 넘겨줄 수 있기 때문입니다.\n",
        "- **동일한 데이터타입끼리 함께 묶어서 넘겨줄 수 있기 때문입니다.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NFntK2xQyiPE"
      },
      "source": [
        "data = {'Country': ['Belgium', 'India', 'Brazil'],\n",
        "        'Capital': ['Brussels', 'New Delhi', 'Brasília'],\n",
        "        'Population': [11190846, 1303171035, 207847528]}\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GSOca-hb6pMi"
      },
      "source": [
        "칼럼명과 마찬가지로 인덱스 역시 변경할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9SKuwsU6yk9N"
      },
      "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",
        "df_2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nanFpU7S07zL"
      },
      "source": [
        "**type()**을 통해 데이터타입이 DataFrame인 걸 확인할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yNtFh6z51Fzh"
      },
      "source": [
        "type(df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lLDAnDLW1Nch"
      },
      "source": [
        "데이터프레임의 하나의 열은 어떤 데이터구조로 되어있을까요?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBB_KeuY08Xp"
      },
      "source": [
        "type(df['Country'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "source": [
        "df.index"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CAle5ksHY94i"
      },
      "source": [
        "df.columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WyVwLH5nY9tZ"
      },
      "source": [
        "df.dtypes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1_gOFVdmZHBI"
      },
      "source": [
        "df.values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KINUU5yxZM3f"
      },
      "source": [
        "Index, columns, dtypes를 한번에 조회하고 싶다면 info()를 사용하세요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j062-g28Y9G6"
      },
      "source": [
        "df.info()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v8tklKsAZsl3"
      },
      "source": [
        "특정한 칼럼을 index로 사용할수도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h0bOGfoEZG7E"
      },
      "source": [
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1sZg4i5pZ2H2"
      },
      "source": [
        "df_index_with_country = df.set_index('Country')\n",
        "\n",
        "df_index_with_country"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eHHIiKfqaIiB"
      },
      "source": [
        "하나의 인덱스만 가능한것은 아닙니다. DataFrame은 여러개의 인덱스를 가질 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-fQTkQ8haBj_"
      },
      "source": [
        "df_index_with_country_and_capital = df.set_index(['Country', 'Capital'])\n",
        "\n",
        "df_index_with_country_and_capital"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "source": [
        "data = {'col1': [1, 2, 3, 4],\n",
        "        'col2': [5, 6, 7, 8],\n",
        "        'col3': [9, 10, 11, 12]}\n",
        "\n",
        "df_3 = pd.DataFrame(data, \n",
        "                    index=['A', 'B', 'C', 'D'])\n",
        "\n",
        "df_3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "wsImXajZunqs"
      },
      "source": [
        "s_1 = pd.Series([1, 2, 3, 4], index=['A', 'B', 'C', 'D'])\n",
        "s_2 = pd.Series([5, 6, 7, 8], index=['A', 'B', 'C', 'D'])\n",
        "s_3 = pd.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 = pd.DataFrame(data, index=['A', 'B', 'C', 'D'])\n",
        "\n",
        "df_4"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "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": []
    }
  ]
}