Do_it_Pandas_11_groupby메서드(그룹연산).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Do_it_Pandas_11_groupby메서드(그룹연산).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "mount_file_id": "1ZYph_K7HkKE_f_sGcNfDGn_y7DZHVnw_",
      "authorship_tag": "ABX9TyOR5JQxZCwfiQV8MBY4acXp",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dianakang/DIANA_Pandas/blob/master/Do_it_Pandas_11_groupby%EB%A9%94%EC%84%9C%EB%93%9C(%EA%B7%B8%EB%A3%B9%EC%97%B0%EC%82%B0).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PfNEhlnGjqxG"
      },
      "source": [
        "# 목차\n",
        "\n",
        "*   11.1. 데이터 집계\n",
        "  *   11.1.1. 데이터 집계하기\n",
        "  *   11.1.2. 분할 - 반영 - 결합 과정 살펴보기 \n",
        "  *   11.1.3. groupby 메서드와 함께 사용하는 집계 메서드\n",
        "  *   11.1.4. age 메서드로 사용자 함수와 groupby 메서드 조합하기\n",
        "      *   (1) 평균값 구하는 사용자 함수와 groupby 메서드\n",
        "      *   (2) 2개의 인자값을 받아 처리하는 사용자 함수와 groupby 메서드\n",
        "  *   11.1.5. 여러 개의 집계 메서드 한 번에 사용하기\n",
        "      *   (1) 리스트에 담아 전달하기\n",
        "      *   (2) 딕셔너리에 담아 전달하기\n",
        "\n",
        "*   11.2. 데이터 변환\n",
        "  *   11.2.1. 표준점수 계산하기\n",
        "  *   11.2.2. 누락값을 평균값으로 처리하기\n",
        "\n",
        "*   11.3. 데이터 필터링 - filter 메서드\n",
        "*   11.4. 그룹 오브젝트\n",
        "   *   11.4.1. 그룹 오브젝트 살펴보기\n",
        "   *   11.4.2. 그룹 오브젝트 계산하기 - 평균 구하기\n",
        "   *   11.4.3. 그룹 오브젝트 활용하기 - 데이터 추출하고 반복하기\n",
        "   *   11.4.4. 여러 열로 그룹 오브젝트 만들고 계산하기\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "34mf_LoijttT"
      },
      "source": [
        "# 11. 그룹 연산"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L_Uiix5wq7rk"
      },
      "source": [
        "## 11.1. 데이터 집계"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XC3H_aJOjxRZ"
      },
      "source": [
        "**판다스의 그룹 연산(groupby())**은 데이터를 집계하거나 변환하는 등의 **작업을 한 번에 처리할 수 있는 강력한 기능**이다. 보통 그룹 연산은 데이터를 '분할'하고 '반영'하고 '결합'하는 과정을 거치게 되는데, '분할'은 어떤 기준으로 데이터를 나누는 것이고, '반영'은 함수 등을 적용하여 데이터를 처리하는 것이다. 그리고 '결합'은 처리한 결과를 다시 합치는 것이다. 보통 이 과정을 하나로 묶어 '분할 - 반영  - 결합(Split - Apply - Combine)'이라고 하며, 이러한 그룹 연산은 대용량의 데이터를 손쉽게 처리할 수 있기 때문에 반드시 알아두어야 한다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q4FOfDH9khHH"
      },
      "source": [
        "### 11.1.1. 데이터 집계하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BEhFoVIKkt4c"
      },
      "source": [
        "수집한 데이터를 바탕으로 평균이나 합 등을 구하여 의미 있는 값을 도출해 내는 것을 '집계'라고 한다. \n",
        "\n",
        "데이터를 집계하면 전체 데이터를 요약, 정리하여 볼 수 있기 때문에 데이터 분석이 훨씬 편해진다. \n",
        "\n",
        "그러면 이제 groupby 메서드로 평균값을 구하는 과정을 통해 데이터 집계가 무엇인지 알아보자."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YyXAyn1rk_00"
      },
      "source": [
        "# 데이터 불러오기\n",
        "import pandas as pd\n",
        "df = pd.read_csv('/content/drive/MyDrive/pandas/doit_pandas-master/data/gapminder.tsv', sep='\\t')"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AoDO0593k_yK",
        "outputId": "47f7476b-3bbf-4a6f-db41-71732936662b"
      },
      "source": [
        "# year 열을 기준으로 그룹화한 후 lifeExp 열의 평균 구하기\n",
        "avg_life_exp_by_year = df.groupby('year').lifeExp.mean()\n",
        "                  #  = df.groupby('year')['lifeExp'].mean()도 같은 결과를 얻음.\n",
        "avg_life_exp_by_year"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "year\n",
              "1952    49.057620\n",
              "1957    51.507401\n",
              "1962    53.609249\n",
              "1967    55.678290\n",
              "1972    57.647386\n",
              "1977    59.570157\n",
              "1982    61.533197\n",
              "1987    63.212613\n",
              "1992    64.160338\n",
              "1997    65.014676\n",
              "2002    65.694923\n",
              "2007    67.007423\n",
              "Name: lifeExp, dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MmIaw-lYlves"
      },
      "source": [
        "### 11.1.2. 분할 - 반영 - 결합 과정 살펴보기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RMWE7ATIl3L-"
      },
      "source": [
        "앞에서 groupby 메서드를 사용해 lifeExp 열의 연도별 평균값을 구했다. \n",
        "\n",
        "그러면 실제로 groupby 메서드는 어떤 과정을 통해 데이터를 집계할까? \n",
        "\n",
        "groupby 메서드 자체를 분해하여 살펴보는 것은 불가능하기 때문에 비슷한 연산을 수행하는 메서드를 순서대로 실행하며 알아보겠다.\n",
        "\n",
        "---\n",
        "\n",
        "1. 실제로 groupby 메서드에 life 열을 전달하면 가장 먼저 연도별로 데이터를 나누는 과정이 진행된다.\n",
        "\n",
        "  다음은 year 열의 데이터를 중복 없이 추출한 것이다. \n",
        "\n",
        "  **groupby 메서드에 열 이름을 전달하면 이런 '분할'작업이 일어난다.**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n1RMkc8Ck_uH",
        "outputId": "f8c43f96-a127-46b1-fc97-5ac4874b9c30"
      },
      "source": [
        "# year 열의 데이터 중복 없이 추출하기\n",
        "years = df.year.unique()   ## unique() = 유일한 값 찾기 메서드\n",
        "years"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1952, 1957, 1962, 1967, 1972, 1977, 1982, 1987, 1992, 1997, 2002,\n",
              "       2007])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zALCQOdqmtsF"
      },
      "source": [
        "2. 그런 다음 연도별로 평균값을 구한다. 그러려면 일단 각 연도별로 데이터를 추출해야한다. \n",
        "\n",
        "  다음은 1952년의 데이터를 추출한 것이다. 이 과정을 '반영' 작업의 한 부분이라고 이해하자."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "a7QxVOHvk_r9",
        "outputId": "c4bab669-7224-4f8e-e9f5-8f00a8515452"
      },
      "source": [
        "# 1952년 데이터 추출하기\n",
        "y1952 = df.loc[df.year == 1952, :]\n",
        "y1952.head()"
      ],
      "execution_count": 4,
      "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>continent</th>\n",
              "      <th>year</th>\n",
              "      <th>lifeExp</th>\n",
              "      <th>pop</th>\n",
              "      <th>gdpPercap</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Afghanistan</td>\n",
              "      <td>Asia</td>\n",
              "      <td>1952</td>\n",
              "      <td>28.801</td>\n",
              "      <td>8425333</td>\n",
              "      <td>779.445314</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>12</th>\n",
              "      <td>Albania</td>\n",
              "      <td>Europe</td>\n",
              "      <td>1952</td>\n",
              "      <td>55.230</td>\n",
              "      <td>1282697</td>\n",
              "      <td>1601.056136</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24</th>\n",
              "      <td>Algeria</td>\n",
              "      <td>Africa</td>\n",
              "      <td>1952</td>\n",
              "      <td>43.077</td>\n",
              "      <td>9279525</td>\n",
              "      <td>2449.008185</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>36</th>\n",
              "      <td>Angola</td>\n",
              "      <td>Africa</td>\n",
              "      <td>1952</td>\n",
              "      <td>30.015</td>\n",
              "      <td>4232095</td>\n",
              "      <td>3520.610273</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>48</th>\n",
              "      <td>Argentina</td>\n",
              "      <td>Americas</td>\n",
              "      <td>1952</td>\n",
              "      <td>62.485</td>\n",
              "      <td>17876956</td>\n",
              "      <td>5911.315053</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        country continent  year  lifeExp       pop    gdpPercap\n",
              "0   Afghanistan      Asia  1952   28.801   8425333   779.445314\n",
              "12      Albania    Europe  1952   55.230   1282697  1601.056136\n",
              "24      Algeria    Africa  1952   43.077   9279525  2449.008185\n",
              "36       Angola    Africa  1952   30.015   4232095  3520.610273\n",
              "48    Argentina  Americas  1952   62.485  17876956  5911.315053"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQlGUZL-nPNf"
      },
      "source": [
        "3. 아직 lifeExp 열의 평균값을 구하지 않았다. 위의 과정에서 추출한 1952년의 데이터에서 lifeExp 열의 평균값을 구해보자. 이 과정도 '반영' 작업의 한 부분이다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_9c11KwDk_qN",
        "outputId": "b687c2f8-934c-4e7c-91c8-f8ae04058606"
      },
      "source": [
        "# 1952년 lifeExp 열의 평균 구하기\n",
        "y1952_mean = y1952.lifeExp.mean()\n",
        "y1952_mean"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "49.05761971830987"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eTHK9VoTnwHb"
      },
      "source": [
        "4. 위의 과정들을 반복하여 남은 연도의 평균값을 구하면 '반영' 작업이 끝난다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lBtgq5cSk_oD",
        "outputId": "b943f2de-19fd-4900-e62b-2d01f1eb7bab"
      },
      "source": [
        "y1957 = df.loc[df.year == 1957, :]\n",
        "y1957_mean = y1957.lifeExp.mean()\n",
        "print(y1957_mean)\n",
        "\n",
        "\n",
        "y1962 = df.loc[df.year == 1962, :]\n",
        "y1962_mean = y1962.lifeExp.mean()\n",
        "print(y1962_mean)\n",
        "\n",
        "\n",
        "y2007 = df.loc[df.year == 2007, :]\n",
        "y2007_mean = y2007.lifeExp.mean()\n",
        "print(y2007_mean)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "51.50740112676054\n",
            "53.60924901408449\n",
            "67.00742253521126\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vPLK_m4loaes"
      },
      "source": [
        "5. 마지막으로 연도별로 계산한 lifeExp의 평균값을 합친다. 바로 이 과정이 '결합'작업이다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "id": "lxG83D-Pk_l2",
        "outputId": "6679b2ee-76f3-43b4-fa77-aae6c56f73b3"
      },
      "source": [
        "df2 = pd.DataFrame({\"year\":[1952, 1957, 1962, 2007],\n",
        "                    \"\":[y1952_mean, y1957_mean, y1962_mean, y2007_mean]})\n",
        "df2"
      ],
      "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>year</th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1952</td>\n",
              "      <td>49.057620</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1957</td>\n",
              "      <td>51.507401</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1962</td>\n",
              "      <td>53.609249</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>2007</td>\n",
              "      <td>67.007423</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   year           \n",
              "0  1952  49.057620\n",
              "1  1957  51.507401\n",
              "2  1962  53.609249\n",
              "3  2007  67.007423"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rwNvsVD_poFs"
      },
      "source": [
        "### 11.1.3. groupby 메서드와 함께 사용하는 집계 메서드"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISrCP3yTpvep"
      },
      "source": [
        "\n",
        "\n",
        "*   **집계 메서드**\n",
        "  *   count - 누락값을 제외한 데이터 수를 반환\n",
        "  *   size - 누락값은 포함한 데이터 수를 반환\n",
        "  *   mean - 평균값 반환\n",
        "  *   std - 표준편차 반환\n",
        "  *   min - 최소값 반환\n",
        "  *   quantile(q=0.25) - 백분위수 25%\n",
        "  *   quantile(q=0.50) - 백분위수 50%\n",
        "  *   quantile(q=0.75) - 백분위수 75%\n",
        "  *   max - 최대값 반환\n",
        "  *   sum - 전체 합 반환\n",
        "  *   var - 분산 반환\n",
        "  *   sem - 평균의 표준편차 반환\n",
        "  *   describe - 데이터 수, 평균, 표준편차, 최소값, 백분위수(25,50,75%), 최대값을 반환\n",
        "  *   first - 첫번째 행 반환\n",
        "  *   last - 마지막 행 반환\n",
        "  *   nth - n번째 행 반환\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0DKjYxL1rF-u"
      },
      "source": [
        "### 11.1.4. age 메서드로 사용자 함수와 groupby 메서드 조합하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y2HM59ylrLxz"
      },
      "source": [
        "라이브러리에서 제공하는 집계 메서드로 원하는 값을 계산할 수 없는 경우에는 직접 함수를 만들어서 사용해야 한다. 이번에는 사용자 함수와 groupby 메서드를 조합해서 사용해보겠다.\n",
        "\n",
        "**사용자 함수와 groupby 메서드를 조합하려면 agg 메서드를 이용해야 한다.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1gHBAcU5sQkN"
      },
      "source": [
        "####  (1) 평균값 구하는 사용자 함수와 groupby 메서드"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KMEh2PlGk_gz"
      },
      "source": [
        "# 입력받은 열의 평균 구하는 함수\n",
        "def my_mean(values):\n",
        "  n = len(values)\n",
        "  sum = 0\n",
        "  \n",
        "  for value in values:\n",
        "    sum += value\n",
        "  \n",
        "  return sum / n"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jIzWe1wHr6rI"
      },
      "source": [
        "다음은 위의 과정에서 만든 함수를 groupby 메서드와 조합하기 위해 agg 메서드를 사용한 것이다. \n",
        "\n",
        "결과를 보면 mean 메서드를 사용하여 얻은 값과 동일하다는 것을 알 수 있다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GF7a_LZ2jeYl",
        "outputId": "18395343-20cc-4846-8fb5-8fc58c9f093e"
      },
      "source": [
        "agg_my_mean = df.groupby('year').lifeExp.agg(my_mean)   ## agg()함수 : 여러개의 함수를 여러 열에 적용 가능\n",
        "agg_my_mean"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "year\n",
              "1952    49.057620\n",
              "1957    51.507401\n",
              "1962    53.609249\n",
              "1967    55.678290\n",
              "1972    57.647386\n",
              "1977    59.570157\n",
              "1982    61.533197\n",
              "1987    63.212613\n",
              "1992    64.160338\n",
              "1997    65.014676\n",
              "2002    65.694923\n",
              "2007    67.007423\n",
              "Name: lifeExp, dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qzd5MSQ4sV1q"
      },
      "source": [
        "#### (2) 2개의 인자값을 받아 처리하는 사용자 함수와 groupby 메서드"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gpowk6x1s6Sq"
      },
      "source": [
        "이번에는 2개의 인자값을 받아 처리하는 사용자 정의 함수(my_mean_diff)를 만들어보겠다. \n",
        "\n",
        "다음은 첫 번째 인자로 받은 열의 평균값을 구하여 두 번째 인자로 받은 값과의 차이를 계산한 다음 반환하는 함수이다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8HSX7Xb3tFHU"
      },
      "source": [
        "# 평균의 차이를 구하는 함수\n",
        "def my_mean_diff(values, diff_value):\n",
        "  n = len(values)\n",
        "  sum = 0\n",
        "\n",
        "  for value in values:\n",
        "    sum += value\n",
        "  mean = sum / n\n",
        "\n",
        "  return mean - diff_value"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6WhqNjTtUDZ"
      },
      "source": [
        "다음은 연도별 평균 수명에서 전체 평균 수명을 뺀 값을 구한 것이다.\n",
        "\n",
        "agg 메서드의 첫 번째 인자에 my_mean_diff 함수를 전달하고 두 번째 인자에 전체 평균 수명값을 전달했다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GgQ4vAORtFFD",
        "outputId": "8f1d9e3b-ea05-4ecf-b4c7-8b2c90f90534"
      },
      "source": [
        "global_mean = df.lifeExp.mean()   ## 전체 평균 수명\n",
        "print(global_mean)\n",
        "\n",
        "# 연도별 평균 수명 - 전체 평균 수명\n",
        "agg_mean_diff = df.groupby('year').lifeExp.agg(my_mean_diff, diff_value=global_mean)\n",
        "print(agg_mean_diff)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "59.47443936619713\n",
            "year\n",
            "1952   -10.416820\n",
            "1957    -7.967038\n",
            "1962    -5.865190\n",
            "1967    -3.796150\n",
            "1972    -1.827053\n",
            "1977     0.095718\n",
            "1982     2.058758\n",
            "1987     3.738173\n",
            "1992     4.685899\n",
            "1997     5.540237\n",
            "2002     6.220483\n",
            "2007     7.532983\n",
            "Name: lifeExp, dtype: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_WWgcTzVvHc0"
      },
      "source": [
        "### 11.1.5. 여러 개의 집계 메서드 한 번에 사용하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B9cY75MVvMXS"
      },
      "source": [
        "**여러 개의 집계 메서드를 한 번에 사용**하고 싶다면 어떻게 해야할까? \n",
        "\n",
        "**집계 메서드를 리스트나 딕셔너리에 담아 agg 메서드에 전달하면 된다.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o7YO6Ck3vpyu"
      },
      "source": [
        "#### (1) 리스트에 담아 전달하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1h3dhP-gvtiO"
      },
      "source": [
        "다음은 연도별로 그룹화한 lifeExp 열의 0이 아닌 값의 개수, 평균, 표준편차를 한 번에 계산하여 출력한 것이다. \n",
        "\n",
        "**넘파이 메서드인 count_nonzero, mean, std를 리스트에 담아 agg 메서드에 전달**했다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "Bupb-NYRvsul",
        "outputId": "27d3f47c-09f7-4cc5-c10b-ed2b3a0d544c"
      },
      "source": [
        "# 리스트에 담아 agg 메서드에 전달하기\n",
        "import numpy as np\n",
        "gdf_list = df.groupby('year').lifeExp.agg([np.count_nonzero, np.mean, np.std])\n",
        "gdf_list"
      ],
      "execution_count": 12,
      "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>count_nonzero</th>\n",
              "      <th>mean</th>\n",
              "      <th>std</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>year</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>1952</th>\n",
              "      <td>142.0</td>\n",
              "      <td>49.057620</td>\n",
              "      <td>12.225956</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1957</th>\n",
              "      <td>142.0</td>\n",
              "      <td>51.507401</td>\n",
              "      <td>12.231286</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1962</th>\n",
              "      <td>142.0</td>\n",
              "      <td>53.609249</td>\n",
              "      <td>12.097245</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1967</th>\n",
              "      <td>142.0</td>\n",
              "      <td>55.678290</td>\n",
              "      <td>11.718858</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1972</th>\n",
              "      <td>142.0</td>\n",
              "      <td>57.647386</td>\n",
              "      <td>11.381953</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1977</th>\n",
              "      <td>142.0</td>\n",
              "      <td>59.570157</td>\n",
              "      <td>11.227229</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1982</th>\n",
              "      <td>142.0</td>\n",
              "      <td>61.533197</td>\n",
              "      <td>10.770618</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1987</th>\n",
              "      <td>142.0</td>\n",
              "      <td>63.212613</td>\n",
              "      <td>10.556285</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1992</th>\n",
              "      <td>142.0</td>\n",
              "      <td>64.160338</td>\n",
              "      <td>11.227380</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1997</th>\n",
              "      <td>142.0</td>\n",
              "      <td>65.014676</td>\n",
              "      <td>11.559439</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2002</th>\n",
              "      <td>142.0</td>\n",
              "      <td>65.694923</td>\n",
              "      <td>12.279823</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2007</th>\n",
              "      <td>142.0</td>\n",
              "      <td>67.007423</td>\n",
              "      <td>12.073021</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "      count_nonzero       mean        std\n",
              "year                                     \n",
              "1952          142.0  49.057620  12.225956\n",
              "1957          142.0  51.507401  12.231286\n",
              "1962          142.0  53.609249  12.097245\n",
              "1967          142.0  55.678290  11.718858\n",
              "1972          142.0  57.647386  11.381953\n",
              "1977          142.0  59.570157  11.227229\n",
              "1982          142.0  61.533197  10.770618\n",
              "1987          142.0  63.212613  10.556285\n",
              "1992          142.0  64.160338  11.227380\n",
              "1997          142.0  65.014676  11.559439\n",
              "2002          142.0  65.694923  12.279823\n",
              "2007          142.0  67.007423  12.073021"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JfwHS18Ow9X-"
      },
      "source": [
        "#### (2) 딕셔너리에 담아 전달하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0IbDGRGMw_pL"
      },
      "source": [
        "이번에는 **집계 메서드를 딕셔너리에 담아 agg 메서드에 전달**해보겠다. \n",
        "\n",
        "딕셔너리의 키로 집계 메서드를 적용할 열 이름을 전달하고 딕셔너리의 값으로 집계 메서드를 전달하면 된다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "HZck4Z_uvLaa",
        "outputId": "a380213f-1b5a-4513-910d-e62dc1b7ed74"
      },
      "source": [
        "# 딕셔너리에 담아 agg 메서드에 전달하기\n",
        "gdf_dict = df.groupby('year').agg({'lifeExp': 'mean', 'pop': 'median', 'gdpPercap':'median'})\n",
        "gdf_dict"
      ],
      "execution_count": 13,
      "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>lifeExp</th>\n",
              "      <th>pop</th>\n",
              "      <th>gdpPercap</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>year</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>1952</th>\n",
              "      <td>49.057620</td>\n",
              "      <td>3943953.0</td>\n",
              "      <td>1968.528344</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1957</th>\n",
              "      <td>51.507401</td>\n",
              "      <td>4282942.0</td>\n",
              "      <td>2173.220291</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1962</th>\n",
              "      <td>53.609249</td>\n",
              "      <td>4686039.5</td>\n",
              "      <td>2335.439533</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1967</th>\n",
              "      <td>55.678290</td>\n",
              "      <td>5170175.5</td>\n",
              "      <td>2678.334741</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1972</th>\n",
              "      <td>57.647386</td>\n",
              "      <td>5877996.5</td>\n",
              "      <td>3339.129407</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1977</th>\n",
              "      <td>59.570157</td>\n",
              "      <td>6404036.5</td>\n",
              "      <td>3798.609244</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1982</th>\n",
              "      <td>61.533197</td>\n",
              "      <td>7007320.0</td>\n",
              "      <td>4216.228428</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1987</th>\n",
              "      <td>63.212613</td>\n",
              "      <td>7774861.5</td>\n",
              "      <td>4280.300366</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1992</th>\n",
              "      <td>64.160338</td>\n",
              "      <td>8688686.5</td>\n",
              "      <td>4386.085502</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1997</th>\n",
              "      <td>65.014676</td>\n",
              "      <td>9735063.5</td>\n",
              "      <td>4781.825478</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2002</th>\n",
              "      <td>65.694923</td>\n",
              "      <td>10372918.5</td>\n",
              "      <td>5319.804524</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2007</th>\n",
              "      <td>67.007423</td>\n",
              "      <td>10517531.0</td>\n",
              "      <td>6124.371109</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        lifeExp         pop    gdpPercap\n",
              "year                                    \n",
              "1952  49.057620   3943953.0  1968.528344\n",
              "1957  51.507401   4282942.0  2173.220291\n",
              "1962  53.609249   4686039.5  2335.439533\n",
              "1967  55.678290   5170175.5  2678.334741\n",
              "1972  57.647386   5877996.5  3339.129407\n",
              "1977  59.570157   6404036.5  3798.609244\n",
              "1982  61.533197   7007320.0  4216.228428\n",
              "1987  63.212613   7774861.5  4280.300366\n",
              "1992  64.160338   8688686.5  4386.085502\n",
              "1997  65.014676   9735063.5  4781.825478\n",
              "2002  65.694923  10372918.5  5319.804524\n",
              "2007  67.007423  10517531.0  6124.371109"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y6lJyjZAxYYI"
      },
      "source": [
        "## 11.2. 데이터 변환"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wxi_x2x4MKnC"
      },
      "source": [
        "이번에는 데이터 변환 메서드에 대해 알아보자. 데이터 변환 메서드는 데이터와 메서드를 일대일로 대응시켜 계산하기 때문에 데이터의 양이 줄어들지는 않는다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Btf_7KaMMtuc"
      },
      "source": [
        "### 11.2.1. 표준점수 계산하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0X50hSJM0RR"
      },
      "source": [
        "통계 분야에서는 데이터의 평균과 표준편차의 차이를 표준점수라고 부른다. \n",
        "\n",
        "=> (표준점수) = (데이터 평균) - (표준편차)\n",
        "\n",
        "**표준점수를 구하면 변환한 데이터의 평균값이 0이되고 표준편차는 1이 된다.**\n",
        "\n",
        "그러면 데이터가 표준화되어 서로 다른 데이터를 쉽게 비교할 수 있다. \n",
        "\n",
        "표준점수는 통계에서 자주 사용하는 지표이며, **Z점수, z-점수** 등 다양한 이름으로 불린다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iR-AMYnmtFC5"
      },
      "source": [
        "# 표준점수 계산하는 함수\n",
        "def my_zscore(x):\n",
        "  return (x - x.mean()) / x.std()"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sgBQ0aiINaTt"
      },
      "source": [
        "다음은 각 연도별 lifeExp 열의 표준점수를 계산한 것이다. my_zscore 함수를 적용하기 위해 transform 메서드를 사용했다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-peUyhtLtFAS",
        "outputId": "89aee167-f6ff-49c1-e12c-6395f974d4e1"
      },
      "source": [
        "# 각 연도 별 lifeExp 열의 표준점수 계산\n",
        "transform_z = df.groupby('year').lifeExp.transform(my_zscore)  ## transform() : 입력된 객체와 동일하게 인덱스된 객체를 반환\n",
        "transform_z.head()"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0   -1.656854\n",
              "1   -1.731249\n",
              "2   -1.786543\n",
              "3   -1.848157\n",
              "4   -1.894173\n",
              "Name: lifeExp, dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f4mp6zXUPoB-"
      },
      "source": [
        "my_zscore 함수는 데이터를 표준화할 뿐 집계는 하지 않는다. 즉, 데이터의 양은 줄어들지 않는다. \n",
        "\n",
        "다음은 원본 데이터프레임(df)의 데이터 크기와 변환한 데이터프레임(transform_z)의 데이터 크기를 비교한 것이다. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1lCq-9eosMNJ",
        "outputId": "128f755a-9e4b-4eb2-a0b3-e8914210854c"
      },
      "source": [
        "# 원본 데이터프레임의 크기 vs 변환한 데이터프레임의 크기 비교\n",
        "print(df.shape)   ## 원본 데이터프레임의 크기\n",
        "print(transform_z.shape)  ## 변환한 데이터프레임의 크기"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1704, 6)\n",
            "(1704,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FhI9rkedQKPj"
      },
      "source": [
        "-> 데이터의 행 개수가 줄어들지 않았다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L22VC_3HQN9k"
      },
      "source": [
        "### 11.2.2. 누락값을 평균값으로 처리하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qC0yvCrcQS-s"
      },
      "source": [
        "지난 6장에서 누락값을 처리하는 다양한 방법들을 살펴보았다. 하지만 가끔은 누락값을 평균값으로 처리하는 것이 더 좋을 때가 있다. \n",
        "\n",
        "이번에는 누락값을 평균값으로 처리하는 방법을 알아보자."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JtcMaoduQnuC"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "1. 다음은 seaborn 라이브러리의 tips 데이터 집합에서 10개의 행 데이터만 가져온 다음 total_bill 열의 값 4개를 임의로 선택하여 누락값으로 바꾼 것이다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OMtziaZcSDCt"
      },
      "source": [
        "\n",
        "\n",
        "*   순열(permutations)\n",
        "\n",
        "반복 가능한 객체(=길이가 n인)에 대해서 중복을 허용하지 않고 r개를 뽑아서 나열한다.\n",
        "\n",
        "뽑힌 순서대로 나열하기 때문에 순서가 의미가 있다. (즉, 같은 값이 뽑히더라도 순서가 다르면 다른 경우의 수로 취급한다.)\n",
        "\n",
        "**: permutations(반복 가능한 객체, r)**\n",
        "\n",
        "(출처: https://juhee-maeng.tistory.com/91)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "id": "MW1NBXiWQHg5",
        "outputId": "99e062d0-7c33-4e51-9212-a2f2269de0d6"
      },
      "source": [
        "# tips 데이터 집합에서 10개의 행 데이터만 가져온 다음, total_bill 열의 값 4개를 누락값으로 바꾸기\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "tips_10 = sns.load_dataset('tips').sample(10)   ## tips 데이터 집합에서 10개의 행 데이터만 가져오기\n",
        "tips_10.loc[np.random.permutation(tips_10.index)[:4], 'total_bill'] = np.NaN   ## permutations(반복 가능한 객체, r)\n",
        "tips_10"
      ],
      "execution_count": 17,
      "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>24</th>\n",
              "      <td>19.82</td>\n",
              "      <td>3.18</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>6</th>\n",
              "      <td>8.77</td>\n",
              "      <td>2.00</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>153</th>\n",
              "      <td>NaN</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>211</th>\n",
              "      <td>NaN</td>\n",
              "      <td>5.16</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Sat</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>198</th>\n",
              "      <td>NaN</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>176</th>\n",
              "      <td>NaN</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192</th>\n",
              "      <td>28.44</td>\n",
              "      <td>2.56</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>124</th>\n",
              "      <td>12.48</td>\n",
              "      <td>2.52</td>\n",
              "      <td>Female</td>\n",
              "      <td>No</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>14.78</td>\n",
              "      <td>3.23</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>101</th>\n",
              "      <td>15.38</td>\n",
              "      <td>3.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Fri</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     total_bill   tip     sex smoker   day    time  size\n",
              "24        19.82  3.18    Male     No   Sat  Dinner     2\n",
              "6          8.77  2.00    Male     No   Sun  Dinner     2\n",
              "153         NaN  2.00    Male     No   Sun  Dinner     4\n",
              "211         NaN  5.16    Male    Yes   Sat  Dinner     4\n",
              "198         NaN  2.00  Female    Yes  Thur   Lunch     2\n",
              "176         NaN  2.00    Male    Yes   Sun  Dinner     2\n",
              "192       28.44  2.56    Male    Yes  Thur   Lunch     2\n",
              "124       12.48  2.52  Female     No  Thur   Lunch     2\n",
              "9         14.78  3.23    Male     No   Sun  Dinner     2\n",
              "101       15.38  3.00  Female    Yes   Fri  Dinner     2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b9K94lg6T0up"
      },
      "source": [
        "2. 그런데 total_bill 열의 누락값을 단순히 total_bill 열의 평균값으로 채우면 안된다. 현재 tips_10의 데이터는 여성보다 남성이 더 많기 때문이다. \n",
        "\n",
        "  즉, 여성과 남성을 구분하여 total_bill 열의 평균값을 구하지 않으면 여성 데이터가 남성 데이터의 영향을 많이 받아 여성 데이터가 훼손될 수 있다.\n",
        "\n",
        "  다음은 성별로 그룹화한 다음 각 열의 데이터 수를 구한 것이다.\n",
        "\n",
        "  total_bill 열을 살펴보면 남성의 누락값은 3개, 여성의 누락값은 1개라는 것을 알 수 있다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 142
        },
        "id": "k1Qf_HIEQjE4",
        "outputId": "fb81460e-b8f4-4591-d124-9a68b63b0003"
      },
      "source": [
        "# 성별로 그룹화한 후, 각 열의 데이터의 수 구하기\n",
        "count_sex = tips_10.groupby('sex').count()\n",
        "count_sex"
      ],
      "execution_count": 18,
      "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>smoker</th>\n",
              "      <th>day</th>\n",
              "      <th>time</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>sex</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>Male</th>\n",
              "      <td>4</td>\n",
              "      <td>7</td>\n",
              "      <td>7</td>\n",
              "      <td>7</td>\n",
              "      <td>7</td>\n",
              "      <td>7</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Female</th>\n",
              "      <td>2</td>\n",
              "      <td>3</td>\n",
              "      <td>3</td>\n",
              "      <td>3</td>\n",
              "      <td>3</td>\n",
              "      <td>3</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        total_bill  tip  smoker  day  time  size\n",
              "sex                                             \n",
              "Male             4    7       7    7     7     7\n",
              "Female           2    3       3    3     3     3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F5Xo96oJUrtO"
      },
      "source": [
        "-> 여성의 tip, smoker, day, time, size 값은 모두 3인데 total_bill의 값은 2이다. 즉, 누락값이 1개이다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ja3WYC9U4Y-"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "3. 다음은 성별을 구분하여 total_bill 열의 데이터를 받아 평균값을 구하는 함수이다. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ca0O40NLQjCX"
      },
      "source": [
        "#  성별 구분한 total_bill 열의 데이터를 받아 평균값 구하는 함수\n",
        "def fill_na_mean(x):\n",
        "  avg = x.mean()\n",
        "  return x.fillna(avg)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FpXTu5zjVMHQ"
      },
      "source": [
        "4. 다음은 **성별을 구분한 total_bill 열의 데이터를 fill_na_mean 함수에 전달하여 평균값을 구한 다음, tips_10에 새로운 열로 추가한 것이다.** \n",
        "\n",
        "  남성과 여성의 **누락값을 고려하여 계산한 평균값으로 잘 채워져 있는 것**을 알 수 있다. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "82GFqQhiQjAV",
        "outputId": "89427b05-d869-45b6-8ca7-39cd0d9b3e92"
      },
      "source": [
        "# fill_total_bill 새로운 열 추가\n",
        "total_bill_group_mean = tips_10.groupby('sex').total_bill.transform(fill_na_mean)\n",
        "tips_10['fill_total_bill'] = total_bill_group_mean\n",
        "print(tips_10)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "     total_bill   tip     sex smoker   day    time  size  fill_total_bill\n",
            "24        19.82  3.18    Male     No   Sat  Dinner     2          19.8200\n",
            "6          8.77  2.00    Male     No   Sun  Dinner     2           8.7700\n",
            "153         NaN  2.00    Male     No   Sun  Dinner     4          17.9525\n",
            "211         NaN  5.16    Male    Yes   Sat  Dinner     4          17.9525\n",
            "198         NaN  2.00  Female    Yes  Thur   Lunch     2          13.9300\n",
            "176         NaN  2.00    Male    Yes   Sun  Dinner     2          17.9525\n",
            "192       28.44  2.56    Male    Yes  Thur   Lunch     2          28.4400\n",
            "124       12.48  2.52  Female     No  Thur   Lunch     2          12.4800\n",
            "9         14.78  3.23    Male     No   Sun  Dinner     2          14.7800\n",
            "101       15.38  3.00  Female    Yes   Fri  Dinner     2          15.3800\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uN_P4DpwWF3M"
      },
      "source": [
        "## 11.3. 데이터 필터링 - filter 메서드"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wDcXG-pBWITN"
      },
      "source": [
        "만약 그룹화한 데이터에서 원하는 데이터를 걸러내고 싶다면 어떻게 해야할까? 그럴 때는 데이터 필터링을 사용하면 된다. \n",
        "\n",
        "**데이터 필터링을 사용하면 기준에 맞는 데이터를 걸러낼 수 있다.**\n",
        "\n",
        "다음 예제를 통해 데이터 필터링이 무엇인지 알아보겠다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xzfivYMiW2ad"
      },
      "source": [
        "\n",
        "---\n",
        "\n",
        "1. 다음과 같이 tips 데이터 집합 불러와 데이터 크기를 확인한다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TFKeVChLQi-X",
        "outputId": "1096ca97-8add-4eff-f115-fcad2d41408d"
      },
      "source": [
        "# 데이터 집합 불러와 크기 확인\n",
        "tips = sns.load_dataset('tips')\n",
        "tips.shape"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(244, 7)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E8IAiqcgXAAa"
      },
      "source": [
        "2. size 열의 데이터 수를 확인헤 보면 1,5,6 테이블의 주문이 매우 적다는 것을 알 수 있다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FSj2sklMQi76",
        "outputId": "d999d842-63c6-4cc8-b47d-abf5cf4dc4ef"
      },
      "source": [
        "# 열의 데이터 수 확인 -> value_count() 이용\n",
        "tips['size'].value_counts()   ## value_counts() : unique value들을 count 해주는 함수"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2    156\n",
              "3     38\n",
              "4     37\n",
              "5      5\n",
              "6      4\n",
              "1      4\n",
              "Name: size, dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "heexss-jXkm1"
      },
      "source": [
        "3. 상황에 따라 이런 데이터는 제외하기도 한다. 만약 30번 이상의 주문이 있는 테이블만 추려 데이터 분석을 하려면 어떻게 해야 할까? \n",
        "\n",
        "  다음은 30번 이상의 주문이 있는 테이블만 그룹화하여 변수 tips_filtered에 저장한 것이다.\n",
        "\n",
        "  (apply lambda식 : https://blog.naver.com/duswjd952/222270779554)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "YxnTb77nQi6C",
        "outputId": "bc8f7280-50c1-4059-a89b-94f570818606"
      },
      "source": [
        "# 30번 이상의 주문이 있는 테이블만 그룹화하기\n",
        "tips_filtered = tips.groupby('size').filter(lambda x: x['size'].count() >= 30)  ## 파이썬의 내장 함수인 filter()는 여러 개의 데이터로부터 일부의 데이터만 추려낼 때 사용\n",
        "tips_filtered.head()"
      ],
      "execution_count": 23,
      "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",
              "  </tbody>\n",
              "</table>\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"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oWhsBSleYa9e"
      },
      "source": [
        "4. 위의 과정을 거치고 나면 1,5,6 테이블의 데이터가 제외되어 총 13개의 데이터가 걸러졌음을 알 수 있다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W2aVnS9TQi1P",
        "outputId": "b1b0b527-f09b-43d0-eca1-3c485a5ce5dc"
      },
      "source": [
        "# 필터링 된 데이터 확인\n",
        "print(tips_filtered.shape)\n",
        "print(tips_filtered['size'].value_counts())"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(231, 7)\n",
            "2    156\n",
            "3     38\n",
            "4     37\n",
            "Name: size, dtype: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IFD_r2J7cW-5"
      },
      "source": [
        "## 11.4. 그룹 오브젝트"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmK7UdDQcdbl"
      },
      "source": [
        "### 11.4.1. 그룹 오브젝트 살펴보기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j6NHkRdGcpSq"
      },
      "source": [
        "지금까지는 groupby 메서드에 바로 집계 메서드를 사용하여 결과를 확인했다. \n",
        "\n",
        "즉, **groupby 메서드가 반환하는 값인 '그룹 오브젝트'**에 대해서는 언급을 하지 않았다. \n",
        "\n",
        "이번에는 groupby 메서드의 결과값인 그룹 오브젝트를 자세히 살펴보겠다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dY-PRSXbYmEa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "outputId": "b2ffa900-8359-4c0b-dbe9-e7625a728d9a"
      },
      "source": [
        "# tips 데이터 집합에서 임의로 10개의 데이터 추출\n",
        "tips_10 = sns.load_dataset('tips').sample(10, random_state=42)  ## random_state = 난수의 초기값 설정\n",
        "tips_10"
      ],
      "execution_count": 25,
      "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>24</th>\n",
              "      <td>19.82</td>\n",
              "      <td>3.18</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>6</th>\n",
              "      <td>8.77</td>\n",
              "      <td>2.00</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>153</th>\n",
              "      <td>24.55</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Male</td>\n",
              "      <td>No</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>211</th>\n",
              "      <td>25.89</td>\n",
              "      <td>5.16</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Sat</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>198</th>\n",
              "      <td>13.00</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>176</th>\n",
              "      <td>17.89</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Sun</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192</th>\n",
              "      <td>28.44</td>\n",
              "      <td>2.56</td>\n",
              "      <td>Male</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>124</th>\n",
              "      <td>12.48</td>\n",
              "      <td>2.52</td>\n",
              "      <td>Female</td>\n",
              "      <td>No</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>14.78</td>\n",
              "      <td>3.23</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>101</th>\n",
              "      <td>15.38</td>\n",
              "      <td>3.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Fri</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     total_bill   tip     sex smoker   day    time  size\n",
              "24        19.82  3.18    Male     No   Sat  Dinner     2\n",
              "6          8.77  2.00    Male     No   Sun  Dinner     2\n",
              "153       24.55  2.00    Male     No   Sun  Dinner     4\n",
              "211       25.89  5.16    Male    Yes   Sat  Dinner     4\n",
              "198       13.00  2.00  Female    Yes  Thur   Lunch     2\n",
              "176       17.89  2.00    Male    Yes   Sun  Dinner     2\n",
              "192       28.44  2.56    Male    Yes  Thur   Lunch     2\n",
              "124       12.48  2.52  Female     No  Thur   Lunch     2\n",
              "9         14.78  3.23    Male     No   Sun  Dinner     2\n",
              "101       15.38  3.00  Female    Yes   Fri  Dinner     2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "994fX5SNcaK8",
        "outputId": "6b6e873d-6edd-46a5-82b2-0a621ddca79c"
      },
      "source": [
        "# groupby 메서드의 결과값 출력 -> 자료형 확인 - '그룹 오브젝트'\n",
        "grouped = tips_10.groupby('sex')   ## sex 열을 그룹화의 기준으로 사용.\n",
        "grouped"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7f878118ec50>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I9sLClrhdjQ9"
      },
      "source": [
        "그룹 오브젝트에 포함된 그룹을 보려면 groups 속성을 출력하면 된다. 그러면 sex 열로 그룹화한 데이터프레임의 인덱스를 확인할 수 있다. \n",
        "\n",
        "이 그룹 오브젝트로 집계, 변환, 필터 작업을 수행하면 된다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3xD8M67CcaHz",
        "outputId": "372e7927-6d80-4d84-b06b-7b84105aedc7"
      },
      "source": [
        "# groups 속성 - 그룹 오브젝트에 포함된 그룹 확인\n",
        "grouped.groups"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Male': [24, 6, 153, 211, 176, 192, 9], 'Female': [198, 124, 101]}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mSHaVH7Rd7B9"
      },
      "source": [
        "### 11.4.2. 그룹 오브젝트 계산하기 - 평균 구하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gDrdx4eteAc1"
      },
      "source": [
        "바로 앞의 실습에서 구한 그룹 오브젝트(grouped)는 smoker, day, time 열과 같은 평균값을 구할 수 없는 열도 포함하고 있다. 이런 그룹 오브젝트에 mean 메서드와 같은 집계 메서드를 사용하면 어떻게 될까? \n",
        "\n",
        "오류가 발생할 거 같지만 다행히 아니다. 파이썬은 자동으로 계산할 수 있는 열을 골라주는 기능을 제공하기 때문에, 그룹 오브젝트에 mean 메서드를 사용해도 바로 평균값을 구할 수 있다. \n",
        "\n",
        "---\n",
        "\n",
        "일단 앞에서 만든 그룹 오브젝트(grouped)를 이용하여 평균을 구해보겠다.\n",
        "\n",
        "그러면 tips 데이터 집합의 모든 열의 평균을 구한 것이 아니라 total_bill, tip, size 열의 평균을 구했다는 것을 알 수 있다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 142
        },
        "id": "dQnrabBqcaEw",
        "outputId": "c2f6bbf0-d865-4be3-8dd6-98fedfbdc935"
      },
      "source": [
        "# 그룹 오브젝트(grouped)의 평균 구하기\n",
        "avgs = grouped.mean()\n",
        "avgs"
      ],
      "execution_count": 28,
      "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",
              "    <tr>\n",
              "      <th>sex</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>Male</th>\n",
              "      <td>20.02</td>\n",
              "      <td>2.875714</td>\n",
              "      <td>2.571429</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Female</th>\n",
              "      <td>13.62</td>\n",
              "      <td>2.506667</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        total_bill       tip      size\n",
              "sex                                   \n",
              "Male         20.02  2.875714  2.571429\n",
              "Female       13.62  2.506667  2.000000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lshn6tE_fOg0"
      },
      "source": [
        "tips 데이터 집합의 열을 확인해보면 **평균값을 계산할 수 없는 열**인 smoker, day, time 열은 **그룹 연산에서 제외**되었다는 것을 알 수 있다.\n",
        "\n",
        "이처럼 파이썬은 그룹 연산에 적합한 열을 알아서 골라준다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S87pv5Y7caB4",
        "outputId": "c87061e6-dc15-48a0-dd67-309672078751"
      },
      "source": [
        "# tips 데이터 집합의 열 확인\n",
        "tips_10.columns"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['total_bill', 'tip', 'sex', 'smoker', 'day', 'time', 'size'], dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTPiQmMnf0gI"
      },
      "source": [
        "### 11.4.3. 그룹 오브젝트 활용하기 - 데이터 추출하고 반복하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v7-csFdVgIHk"
      },
      "source": [
        "\n",
        "\n",
        "*   그룹 오브젝트 다양하게 활용하는 방법\n",
        "\n",
        ": https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eaAJI12OggAS"
      },
      "source": [
        "만약 **그룹 오브젝트에서 특정 데이터만 추출하려면 get_group 메서드를 사용**하면 된다. 다음은 sex 열로 그룹화한 그룹 오브젝트에 get_group 메서드를 사용하여 성별이 여성인 데이터만 추출한 것이다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 142
        },
        "id": "Tu_f7LwZf3li",
        "outputId": "6e4371a0-3f40-43df-e9cf-5ce7122c8914"
      },
      "source": [
        "# 성별이 여성인 데이터만 추출\n",
        "female = grouped.get_group('Female')  ## get_group() : 그룹 오브젝트에서 특정 데이터만 추출\n",
        "female"
      ],
      "execution_count": 30,
      "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>198</th>\n",
              "      <td>13.00</td>\n",
              "      <td>2.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>124</th>\n",
              "      <td>12.48</td>\n",
              "      <td>2.52</td>\n",
              "      <td>Female</td>\n",
              "      <td>No</td>\n",
              "      <td>Thur</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>101</th>\n",
              "      <td>15.38</td>\n",
              "      <td>3.00</td>\n",
              "      <td>Female</td>\n",
              "      <td>Yes</td>\n",
              "      <td>Fri</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     total_bill   tip     sex smoker   day    time  size\n",
              "198       13.00  2.00  Female    Yes  Thur   Lunch     2\n",
              "124       12.48  2.52  Female     No  Thur   Lunch     2\n",
              "101       15.38  3.00  Female    Yes   Fri  Dinner     2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KHKjyJ-Gg9yY"
      },
      "source": [
        "이번에는 그룹 오브젝트를 반복문에 사용해보겠다. sex 열을 기준으로 그룹화한 tips 데이터 집합은 여성 그룹과 남성 그룹으로 나누어져 있다. \n",
        "\n",
        "이 특징을 이용하여 반복문을 사용하면 된다. 다음은 각 성별 그룹의 데이터를 반복문을 이용하여 출력한 것이다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nEpa2AH3f3iw",
        "outputId": "9dd2fac2-31e5-4fa4-8999-9c3d819a9247"
      },
      "source": [
        "# 그룹 오브젝트를 반복문에 사용\n",
        "for sex_group in grouped:\n",
        "  print(sex_group)       ## 주의!! for문 출력할 때는 꼭 print 써줘야한다."
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('Male',      total_bill   tip   sex smoker   day    time  size\n",
            "24        19.82  3.18  Male     No   Sat  Dinner     2\n",
            "6          8.77  2.00  Male     No   Sun  Dinner     2\n",
            "153       24.55  2.00  Male     No   Sun  Dinner     4\n",
            "211       25.89  5.16  Male    Yes   Sat  Dinner     4\n",
            "176       17.89  2.00  Male    Yes   Sun  Dinner     2\n",
            "192       28.44  2.56  Male    Yes  Thur   Lunch     2\n",
            "9         14.78  3.23  Male     No   Sun  Dinner     2)\n",
            "('Female',      total_bill   tip     sex smoker   day    time  size\n",
            "198       13.00  2.00  Female    Yes  Thur   Lunch     2\n",
            "124       12.48  2.52  Female     No  Thur   Lunch     2\n",
            "101       15.38  3.00  Female    Yes   Fri  Dinner     2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJYFgrich8e_"
      },
      "source": [
        "-> 결과를 살펴보면 sex_group으로 넘어온 값이 튜플이라는 것을 알 수 있다.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VyH2IqCFf3g7",
        "outputId": "3b134711-2a58-4598-c625-791f1e9b7c09"
      },
      "source": [
        "# sex_group의 자세한 정보 출력\n",
        "for sex_group in grouped:\n",
        "  print('the type is: {}\\n'.format(type(sex_group)))   ## \\n : 문자열 안에서 줄 바꿀 때 사용\n",
        "  print('the length is: {}\\n'.format(len(sex_group)))\n",
        "\n",
        "  first_element = sex_group[0]\n",
        "  print('the first element is:{}\\n'.format(first_element))\n",
        "  print('it has a type of: {}\\n'.format(type(sex_group[0])))\n",
        "\n",
        "  second_element = sex_group[1]\n",
        "  print('the second element is:\\n{}\\n'.format(second_element))\n",
        "  print('it has a type of: {}\\n'.format(type(second_element)))\n",
        "\n",
        "  print('what we have:')\n",
        "  print(sex_group)\n",
        "\n",
        "  break"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "the type is: <class 'tuple'>\n",
            "\n",
            "the length is: 2\n",
            "\n",
            "the first element is:Male\n",
            "\n",
            "it has a type of: <class 'str'>\n",
            "\n",
            "the second element is:\n",
            "     total_bill   tip   sex smoker   day    time  size\n",
            "24        19.82  3.18  Male     No   Sat  Dinner     2\n",
            "6          8.77  2.00  Male     No   Sun  Dinner     2\n",
            "153       24.55  2.00  Male     No   Sun  Dinner     4\n",
            "211       25.89  5.16  Male    Yes   Sat  Dinner     4\n",
            "176       17.89  2.00  Male    Yes   Sun  Dinner     2\n",
            "192       28.44  2.56  Male    Yes  Thur   Lunch     2\n",
            "9         14.78  3.23  Male     No   Sun  Dinner     2\n",
            "\n",
            "it has a type of: <class 'pandas.core.frame.DataFrame'>\n",
            "\n",
            "what we have:\n",
            "('Male',      total_bill   tip   sex smoker   day    time  size\n",
            "24        19.82  3.18  Male     No   Sat  Dinner     2\n",
            "6          8.77  2.00  Male     No   Sun  Dinner     2\n",
            "153       24.55  2.00  Male     No   Sun  Dinner     4\n",
            "211       25.89  5.16  Male    Yes   Sat  Dinner     4\n",
            "176       17.89  2.00  Male    Yes   Sun  Dinner     2\n",
            "192       28.44  2.56  Male    Yes  Thur   Lunch     2\n",
            "9         14.78  3.23  Male     No   Sun  Dinner     2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KFAPOTfajtID"
      },
      "source": [
        "### 11.4.4. 여러 열로 그룹 오브젝트 만들고 계산하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YjM3QDdIjxCk"
      },
      "source": [
        "지금까지는 하나의 열을 사용하여 그룹 오브젝트를 만들고 연산을 수행했다. \n",
        "\n",
        "하지만 여러 열을 사용하여 그룹 오브젝트를 만들고 평균값을 구하는 등의 계산도 할 수 있다.\n",
        "\n",
        "---\n",
        "\n",
        "**여러 열을 사용하여 데이터를 그룹화**하려면 **리스트에 열 이름을 담아 groupby 메서드에 전달**하면 된다. \n",
        "\n",
        "다음은 sex, time 열을 기준으로 데이터를 그룹화하고 평균값을 구한 것이다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "5qEd2taNf3bt",
        "outputId": "389d4b8d-b58e-4d86-ab56-bed6c7080eca"
      },
      "source": [
        "# sex, time 열을 기준으로 그룹화하여 평균값 계산\n",
        "bill_sex_time = tips_10.groupby(['sex', 'time'])\n",
        "group_avg = bill_sex_time.mean()\n",
        "\n",
        "group_avg"
      ],
      "execution_count": 36,
      "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>total_bill</th>\n",
              "      <th>tip</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>sex</th>\n",
              "      <th>time</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th rowspan=\"2\" valign=\"top\">Male</th>\n",
              "      <th>Lunch</th>\n",
              "      <td>28.440000</td>\n",
              "      <td>2.560000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Dinner</th>\n",
              "      <td>18.616667</td>\n",
              "      <td>2.928333</td>\n",
              "      <td>2.666667</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th rowspan=\"2\" valign=\"top\">Female</th>\n",
              "      <th>Lunch</th>\n",
              "      <td>12.740000</td>\n",
              "      <td>2.260000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Dinner</th>\n",
              "      <td>15.380000</td>\n",
              "      <td>3.000000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "               total_bill       tip      size\n",
              "sex    time                                  \n",
              "Male   Lunch    28.440000  2.560000  2.000000\n",
              "       Dinner   18.616667  2.928333  2.666667\n",
              "Female Lunch    12.740000  2.260000  2.000000\n",
              "       Dinner   15.380000  3.000000  2.000000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpG4IsTYknyD"
      },
      "source": [
        "위의 과정을 통해 group_avg의 자료형을 확인해보면 데이터프레임이라는 것을 알 수 있다. 그리고 변수 group_avg에 포함된 열은 total_bill, tip, size라는 것도 알 수 있다. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "STj0YpN0fi8o",
        "outputId": "4522d413-4d1f-4eba-c7a8-3284e2bdcc78"
      },
      "source": [
        "# group_avg의 자료형 확인 \n",
        "print(type(group_avg))  ## 데이터프레임\n",
        "\n",
        "# group_avg의 칼럼 확인\n",
        "print(group_avg.columns)  ## total_bill, tip, size"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Index(['total_bill', 'tip', 'size'], dtype='object')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xsmT_Nx3lEcP",
        "outputId": "ec395291-763c-4301-96d3-021519904220"
      },
      "source": [
        "# group_avg의 인덱스 확인\n",
        "group_avg.index"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultiIndex([(  'Male',  'Lunch'),\n",
              "            (  'Male', 'Dinner'),\n",
              "            ('Female',  'Lunch'),\n",
              "            ('Female', 'Dinner')],\n",
              "           names=['sex', 'time'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7f12Do7QlQgL"
      },
      "source": [
        "-> 이렇게 여러 인덱스를 담고 있는 인덱스는 Multiindex라고 부른다.\n",
        "\n",
        "---\n",
        "\n",
        "이처러머 데이터프레임의 인덱스가 **Multiindex인 경우에는 reset_index 메서드를 사용하여 데이터프레임의 인덱스를 새로 부여**할 수도 있다.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "id": "1d0xi1kMlLdI",
        "outputId": "6f6d65d4-36b4-4b4d-ab21-0192ae5d7fbf"
      },
      "source": [
        "# 데이터프레임의 인덱스 새로 지정 -> reset_index() 사용\n",
        "group_method = tips_10.groupby(['sex','time']).mean().reset_index()  \n",
        "## 출력값을 잘 볼것!! \n",
        "\n",
        "group_method"
      ],
      "execution_count": 39,
      "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>sex</th>\n",
              "      <th>time</th>\n",
              "      <th>total_bill</th>\n",
              "      <th>tip</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Male</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>28.440000</td>\n",
              "      <td>2.560000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Male</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>18.616667</td>\n",
              "      <td>2.928333</td>\n",
              "      <td>2.666667</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Female</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>12.740000</td>\n",
              "      <td>2.260000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Female</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>15.380000</td>\n",
              "      <td>3.000000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "      sex    time  total_bill       tip      size\n",
              "0    Male   Lunch   28.440000  2.560000  2.000000\n",
              "1    Male  Dinner   18.616667  2.928333  2.666667\n",
              "2  Female   Lunch   12.740000  2.260000  2.000000\n",
              "3  Female  Dinner   15.380000  3.000000  2.000000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cM_5TMTsmWlJ"
      },
      "source": [
        "**reset_index 메서드 대신 as_index 인자를 False로 설정해도 위와 같은 결과를 얻는다.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "id": "Wce74I44l0FZ",
        "outputId": "08843fc1-6180-4d5f-90b2-5c918b92923f"
      },
      "source": [
        "# 데이터프레임의 인덱스 새로 지정 -> as_index 구문 사용\n",
        "group_param = tips_10.groupby(['sex','time'], as_index=False).mean()  ## as_index= True/False => 이 그룹을 인덱스로 지정할 것인지 여부\n",
        "group_param"
      ],
      "execution_count": 40,
      "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>sex</th>\n",
              "      <th>time</th>\n",
              "      <th>total_bill</th>\n",
              "      <th>tip</th>\n",
              "      <th>size</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Male</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>28.440000</td>\n",
              "      <td>2.560000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Male</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>18.616667</td>\n",
              "      <td>2.928333</td>\n",
              "      <td>2.666667</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Female</td>\n",
              "      <td>Lunch</td>\n",
              "      <td>12.740000</td>\n",
              "      <td>2.260000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Female</td>\n",
              "      <td>Dinner</td>\n",
              "      <td>15.380000</td>\n",
              "      <td>3.000000</td>\n",
              "      <td>2.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "      sex    time  total_bill       tip      size\n",
              "0    Male   Lunch   28.440000  2.560000  2.000000\n",
              "1    Male  Dinner   18.616667  2.928333  2.666667\n",
              "2  Female   Lunch   12.740000  2.260000  2.000000\n",
              "3  Female  Dinner   15.380000  3.000000  2.000000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TZt30pIHnH5x"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "---\n",
        "\n",
        "이번 11장에서는 groupby 메서드의 분리 - 반영 - 결합 과정을 구체적으로 살펴보고 데이터를 집계, 변환, 필터링하는 방법을 알아보았다. 또 여러 가지 방법으로 그룹 오브젝트를 만들고 계산하는 방법도 알아보았다. 데이터를 그룹화하여 계산하는 작업은 실무에서 자주 사용하므로 반드시 알아두어야 한다!"
      ]
    }
  ]
}