CH03-03. Series, DataFrame 다루기.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [ 3-3. Series, DataFrame 다루기 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Series 다루기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-1. Series의 주요 속성\n",
    "\n",
    "* index : Series의 인덱스 객체를 반환합니다. 인덱스는 Series의 각 데이터 포인트에 할당된 라벨입니다.\n",
    "\n",
    "* values : Series의 데이터를 numpy 배열 형태로 반환합니다.\n",
    "\n",
    "* dtype : Series에 저장된 데이터의 타입을 반환합니다. 예를 들어, 'float64', 'int64', 'object' 등 입니다.\n",
    "\n",
    "* shape : Series의 형태를 나타내며, (n, ) 형태의 튜플을 반환합니다. 여기서 'n'은 데이터의 수입니다.\n",
    "\n",
    "* size : Series에 있는 데이터 항목의 총 개수를 반환합니다.\n",
    "\n",
    "* name : Series의 이름을 반환하거나 설정합니다. Series 객체를 생성할 때 name 매개변수를 통해 이름을 할당할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-2. Series의 주요 속성 사용 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas import Series\n",
    "data = Series(\n",
    "    [10, 20, 30, 40, 50], \n",
    "    index=['a', 'b', 'c', 'd', 'e'], \n",
    "    name='numbers'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['a', 'b', 'c', 'd', 'e'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(data.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40 50]\n"
     ]
    }
   ],
   "source": [
    "print(data.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n"
     ]
    }
   ],
   "source": [
    "print(data.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(data.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numbers\n"
     ]
    }
   ],
   "source": [
    "print(data.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new_numbers\n"
     ]
    }
   ],
   "source": [
    "data.name = 'new_numbers'\n",
    "print(data.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-3. Series의 주요 메서드\n",
    "\n",
    "* head(n=5) : Series의 처음부터 'n'개의 항목을 반환합니다. 'n'을 지정하지 않으면 기본값은 5입니다.\n",
    "\n",
    "* tail(n=5) : Series의 끝에서부터 'n'개의 항목을 반환합니다. 'n'을 지정하지 않으면 기본값은 5입니다.\n",
    "\n",
    "* describe() : Series의 요약 통계를 반환합니다. 평균, 표준편차, 최소값, 최대값 등의 통계 정보를 제공합니다.\n",
    "\n",
    "* unique() : Series에서 고유한 값들의 배열을 반환합니다.\n",
    "\n",
    "* value_counts() : Series에서 각 값의 출현 빈도를 계산하여 반환합니다.\n",
    "\n",
    "* apply(func) : Series의 각 요소에 함수 func을 적용합니다.\n",
    "\n",
    "* sort_values(ascending=True) : Series의 값을 기준으로 오름차순(또는 내림차순)으로 정렬합니다.\n",
    "\n",
    "* sort_index(ascending=True) : Series의 인덱스를 기준으로 오름차순(또는 내림차순)으로 정렬합니다.\n",
    "\n",
    "* isnull() : Series의 각 요소가 NaN(Not a Number)인지 아닌지를 나타내는 불리언 배열을 반환합니다. 즉, 개별 값에 대하여 NaN이면 True, NaN이 아니면 False를 도출하여 최종적으로 True와 False로 이루어진 배열을 반환합니다.\n",
    "\n",
    "* notnull() : isnull()과는 반대로, Series의 각 요소가 NaN이 아닌 경우 True를 반환합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-4. Series의 주요 메서드 사용 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1.0\n",
      "1    2.0\n",
      "2    NaN\n",
      "3    4.0\n",
      "4    5.0\n",
      "5    NaN\n",
      "6    7.0\n",
      "7    8.0\n",
      "8    9.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pandas import Series\n",
    "\n",
    "data = Series([1, 2, np.nan, 4, 5, np.nan, 7, 8, 9])\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1.0\n",
      "1    2.0\n",
      "2    NaN\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.head(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6    7.0\n",
      "7    8.0\n",
      "8    9.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.tail(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    7.000000\n",
      "mean     5.142857\n",
      "std      3.023716\n",
      "min      1.000000\n",
      "25%      3.000000\n",
      "50%      5.000000\n",
      "75%      7.500000\n",
      "max      9.000000\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  2. nan  4.  5.  7.  8.  9.]\n"
     ]
    }
   ],
   "source": [
    "print(data.unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0    1\n",
      "2.0    1\n",
      "4.0    1\n",
      "5.0    1\n",
      "7.0    1\n",
      "8.0    1\n",
      "9.0    1\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(data.value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     2.0\n",
      "1     4.0\n",
      "2     NaN\n",
      "3     8.0\n",
      "4    10.0\n",
      "5     NaN\n",
      "6    14.0\n",
      "7    16.0\n",
      "8    18.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.apply(lambda x: x * 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1.0\n",
      "1    2.0\n",
      "3    4.0\n",
      "4    5.0\n",
      "6    7.0\n",
      "7    8.0\n",
      "8    9.0\n",
      "2    NaN\n",
      "5    NaN\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.sort_values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8    9.0\n",
      "7    8.0\n",
      "6    7.0\n",
      "4    5.0\n",
      "3    4.0\n",
      "1    2.0\n",
      "0    1.0\n",
      "2    NaN\n",
      "5    NaN\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.sort_values(ascending=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8    9.0\n",
      "7    8.0\n",
      "6    7.0\n",
      "5    NaN\n",
      "4    5.0\n",
      "3    4.0\n",
      "2    NaN\n",
      "1    2.0\n",
      "0    1.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(data.sort_index(ascending=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    False\n",
      "1    False\n",
      "2     True\n",
      "3    False\n",
      "4    False\n",
      "5     True\n",
      "6    False\n",
      "7    False\n",
      "8    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "print(data.isnull())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     True\n",
      "1     True\n",
      "2    False\n",
      "3     True\n",
      "4     True\n",
      "5    False\n",
      "6     True\n",
      "7     True\n",
      "8     True\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "print(data.notnull())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-5. Series 객체들 사이에서의 연산\n",
    "Series 객체들 사이에서 연산을 수행하는 것은 매우 직관적이며, Python의 기본 연산자를 사용하여 쉽게 할 수 있습니다. Series 객체들 사이의 연산은 기본적으로 인덱스에 맞춰서 이루어집니다. 이는 각 연산에서 대응되는 인덱스의 값끼리 연산이 수행된다는 것을 의미합니다. 만약 일치하는 인덱스가 없는 경우, 결과는 'NaN' (Not a Number, 즉, 결측치를 의미)을 표시됩니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1-5-1. 기본 연산 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "더하기 결과:\n",
      " a    2\n",
      "b    4\n",
      "c    6\n",
      "d    8\n",
      "dtype: int64\n",
      "빼기 결과:\n",
      " a    0\n",
      "b    0\n",
      "c    0\n",
      "d    0\n",
      "dtype: int64\n",
      "곱하기 결과:\n",
      " a     1\n",
      "b     4\n",
      "c     9\n",
      "d    16\n",
      "dtype: int64\n",
      "나누기 결과:\n",
      " a    1.0\n",
      "b    1.0\n",
      "c    1.0\n",
      "d    1.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Series 객체 생성\n",
    "s1 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n",
    "s2 = pd.Series([4, 3, 2, 1], index=['d', 'c', 'b', 'a'])\n",
    "\n",
    "# 더하기\n",
    "add_result = s1 + s2\n",
    "\n",
    "# 빼기\n",
    "sub_result = s1 - s2\n",
    "\n",
    "# 곱하기\n",
    "mul_result = s1 * s2\n",
    "\n",
    "# 나누기\n",
    "div_result = s1 / s2\n",
    "\n",
    "print(\"더하기 결과:\\n\", add_result)\n",
    "print(\"빼기 결과:\\n\", sub_result)\n",
    "print(\"곱하기 결과:\\n\", mul_result)\n",
    "print(\"나누기 결과:\\n\", div_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1-5-2. 브로드캐스팅\n",
    "Series와 스칼라 값(단일 숫자 값) 사이의 연산도 가능합니다. 이 경우 스칼라 값은 Series의 모든 요소에 대해 연산이 적용됩니다. 이를 브로드캐스팅이라고 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "스칼라 더하기 결과:\n",
      " a    6\n",
      "b    7\n",
      "c    8\n",
      "d    9\n",
      "dtype: int64\n",
      "스칼라 곱하기 결과:\n",
      " a    2\n",
      "b    4\n",
      "c    6\n",
      "d    8\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 스칼라 값과의 연산\n",
    "scalar_add = s1 + 5\n",
    "scalar_mul = s1 * 2\n",
    "\n",
    "print(\"스칼라 더하기 결과:\\n\", scalar_add)\n",
    "print(\"스칼라 곱하기 결과:\\n\", scalar_mul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1-5-3. 불리언 인덱싱\n",
    "불리언 배열을 사용하여 Series에서 특정 조건에 맞는 값을 추출할 수 있습니다. 불리언 인덱싱은 조건을 만족하는(True) 데이터만 선택적으로 추출할 수 있도록 해줍니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    0\n",
      "1    1\n",
      "2    2\n",
      "3    3\n",
      "4    4\n",
      "5    5\n",
      "6    6\n",
      "7    7\n",
      "8    8\n",
      "9    9\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "s = pd.Series(range(10))\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2    False\n",
       "3    False\n",
       "4    False\n",
       "5    False\n",
       "6     True\n",
       "7     True\n",
       "8     True\n",
       "9     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6    6\n",
       "7    7\n",
       "8    8\n",
       "9    9\n",
       "dtype: int64"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[s > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. DataFrame 다루기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-1. DataFrame의 주요 속성\n",
    "\n",
    "* index : DataFrame의 행 레이블(인덱스)입니다. 기본적으로, 이는 0부터 시작하는 정수 인덱스이지만, 시계열 데이터와 같이 다른 레이블을 가질 수도 있습니다.\n",
    "\n",
    "* columns : DataFrame의 열 이름을 나타냅니다.\n",
    "\n",
    "* dtypes : DataFrame 내 각 열의 데이터 타입을 나타내는 Series입니다.\n",
    "\n",
    "* shape : DataFrame의 형태를 나타내는 튜플입니다.(행의 수, 열의 수)\n",
    "\n",
    "* size : DataFrame에 있는 전체 요소의 수입니다. 행의 수 x 열의 수로 계산됩니다.\n",
    "\n",
    "* values : DataFrame의 데이터를 NumPy 배열로 반환합니다. 이를 통해 DataFrame 데이터를 NumPy 라이브러리를 사용하여 처리할 수 있습니다.\n",
    "\n",
    "* T : DataFrame의 전치를 반환합니다. 즉, 행과 열을 바꾼 DataFrame을 생성합니다.\n",
    "\n",
    "* axes : DataFrame의 행과 열 레이블을 리스트로 반환합니다. 첫 번째 요소는 행 레이블(index), 두 번째 요소는 열 레이블(columns) 입니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-2. DataFrame의 주요 속성 사용 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City\n",
      "0   John   28  New York\n",
      "1   Anna   34     Paris\n",
      "2  Peter   29    Berlin\n",
      "3  Linda   32    London\n"
     ]
    }
   ],
   "source": [
    "from pandas import DataFrame\n",
    "\n",
    "data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],\n",
    "        'Age': [28, 34, 29, 32],\n",
    "        'City': ['New York', 'Paris', 'Berlin', 'London']}\n",
    "\n",
    "df = DataFrame(data)\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RangeIndex(start=0, stop=4, step=1)\n"
     ]
    }
   ],
   "source": [
    "print(df.index)\n",
    "# RangeIndex 객체(Generator) 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Name', 'Age', 'City'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name    object\n",
      "Age      int64\n",
      "City    object\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(df.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 3)\n"
     ]
    }
   ],
   "source": [
    "print(df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print(df.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['John' 28 'New York']\n",
      " ['Anna' 34 'Paris']\n",
      " ['Peter' 29 'Berlin']\n",
      " ['Linda' 32 'London']]\n"
     ]
    }
   ],
   "source": [
    "print(df.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             0      1       2       3\n",
      "Name      John   Anna   Peter   Linda\n",
      "Age         28     34      29      32\n",
      "City  New York  Paris  Berlin  London\n"
     ]
    }
   ],
   "source": [
    "print(df.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City\n",
      "0   John   28  New York\n",
      "1   Anna   34     Paris\n",
      "2  Peter   29    Berlin\n",
      "3  Linda   32    London\n"
     ]
    }
   ],
   "source": [
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[RangeIndex(start=0, stop=4, step=1), Index(['Name', 'Age', 'City'], dtype='object')]\n"
     ]
    }
   ],
   "source": [
    "print(df.axes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-3. DataFrame의 주요 메서드\n",
    "\n",
    "* head(n=5) : DataFrame의 처음 n행을 반환합니다. 기본값은 5입니다.\n",
    "\n",
    "* tail(n=5) : DataFrame의 마지막 n행을 반환합니다. 기본값은 5입니다.\n",
    "\n",
    "* describe() : 숫자형 열에 대한 주요 통계량(카운트, 평균, 표준편차, 최소값, 최대값 등)을 요약하여 보여줍니다.\n",
    "\n",
    "* info() : DataFrame의 주요 정보를 출력합니다. 인덱스의 데이터 타입과 열, 비-결측치 값의 개수, 메모리 사용량 등이 포함됩니다.\n",
    "\n",
    "* mean() : 숫자형 열의 평균값을 계산합니다.\n",
    "\n",
    "* sum() : 숫자형 열의 합계를 계산합니다.\n",
    "\n",
    "* max() : 각 열의 최대값을 찾습니다.\n",
    "\n",
    "* min() : 각 열의 최소값을 찾습니다.\n",
    "\n",
    "* drop(labels=None, axis=0, inplace=False) : 지정된 레이블의 행이나 열을 제거합니다. axis=0은 행을, axis=1은 열을 의미합니다. inplace=True로 설정하면 변경사항을 원본 DataFrame에 바로 적용합니다.\n",
    "\n",
    "* apply(func, axis=0) : 함수 func를 DataFrame의 열 또는 행에 적용합니다. axis=0은 행 방향으로 함수를 적용합니다. 향 방향으로 이동하면서 각 열에 대해 지정된 함수를 적용합니다. axis=1은 열 방향으로 함수를 적용합니다. 즉, 열 방향으로 이동하면서 각 행 전체에 대해 함수를 적용합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-4. DataFrame의 주요 메서드 사용 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age  Salary\n",
      "0   John   28   50000\n",
      "1   Anna   34   62000\n",
      "2  Peter   29   58000\n",
      "3  Linda   32   74000\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pandas import DataFrame\n",
    "\n",
    "data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],\n",
    "        'Age': [28, 34, 29, 32],\n",
    "        'Salary': [50000, 62000, 58000, 74000]}\n",
    "df = DataFrame(data)\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Name  Age  Salary\n",
      "0  John   28   50000\n",
      "1  Anna   34   62000\n"
     ]
    }
   ],
   "source": [
    "print(df.head(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age  Salary\n",
      "1   Anna   34   62000\n",
      "2  Peter   29   58000\n",
      "3  Linda   32   74000\n"
     ]
    }
   ],
   "source": [
    "print(df.tail(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             Age   Salary\n",
      "count   4.000000      4.0\n",
      "mean   30.750000  61000.0\n",
      "std     2.753785  10000.0\n",
      "min    28.000000  50000.0\n",
      "25%    28.750000  56000.0\n",
      "50%    30.500000  60000.0\n",
      "75%    32.500000  65000.0\n",
      "max    34.000000  74000.0\n"
     ]
    }
   ],
   "source": [
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 4 entries, 0 to 3\n",
      "Data columns (total 3 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   Name    4 non-null      object\n",
      " 1   Age     4 non-null      int64 \n",
      " 2   Salary  4 non-null      int64 \n",
      "dtypes: int64(2), object(1)\n",
      "memory usage: 228.0+ bytes\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(df.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          30.75\n",
      "Salary    61000.00\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          123\n",
      "Salary    244000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          34\n",
      "Salary    74000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          28\n",
      "Salary    50000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Salary\n",
      "0   John   50000\n",
      "1   Anna   62000\n",
      "2  Peter   58000\n",
      "3  Linda   74000\n"
     ]
    }
   ],
   "source": [
    "print(df.drop('Age', axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name\n",
      "0   John\n",
      "1   Anna\n",
      "2  Peter\n",
      "3  Linda\n"
     ]
    }
   ],
   "source": [
    "print(df.drop(['Age', 'Salary'], axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age  Salary\n",
      "0   John   28   50000\n",
      "3  Linda   32   74000\n"
     ]
    }
   ],
   "source": [
    "print(df.drop([1, 2], axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age  Salary\n",
      "0   John   28   50000\n",
      "3  Linda   32   74000\n"
     ]
    }
   ],
   "source": [
    "print(df.drop(range(1, 3), axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          123\n",
      "Salary    244000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].apply(sum, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          30.75\n",
      "Salary    61000.00\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].apply(np.mean, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          28\n",
      "Salary    50000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].apply(min, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age          34\n",
      "Salary    74000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].apply(max, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age              3805\n",
      "Salary    15184000000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df[['Age', 'Salary']].apply(lambda x: sum(x**2), axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-5. Series 객체들 사이에서의 연산\n",
    "pandas는 두 DataFrame 간의 연산을 지원하며 데이터 분석과정에서 다양한 수치 계산을 수행할 수 있습니다. 이러한 연산은 각 DataFrame의 동일한 위치에 있는 데이터끼리 수행되며, 기본적으로 더하기, 빼기, 곱하기, 나누기 등의 연산이 가능합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2-5-1. 기본 연산 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   A  B  C\n",
      "0  0  1  2\n",
      "1  3  4  5\n",
      "2  6  7  8\n",
      "    A   B   C\n",
      "0   4   5   6\n",
      "1   7   8   9\n",
      "2  10  11  12\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pandas import DataFrame\n",
    "\n",
    "df1 = DataFrame(np.arange(9).reshape(3, 3), columns=list('ABC'))\n",
    "df2 = DataFrame(np.arange(4, 13).reshape(3, 3), columns=list('ABC'))\n",
    "\n",
    "print(df1)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "더하기 결과:\n",
      "     A   B   C\n",
      "0   4   6   8\n",
      "1  10  12  14\n",
      "2  16  18  20\n",
      "빼기 결과:\n",
      "    A  B  C\n",
      "0 -4 -4 -4\n",
      "1 -4 -4 -4\n",
      "2 -4 -4 -4\n",
      "곱하기 결과:\n",
      "     A   B   C\n",
      "0   0   5  12\n",
      "1  21  32  45\n",
      "2  60  77  96\n",
      "나누기 결과:\n",
      "           A         B         C\n",
      "0  0.000000  0.200000  0.333333\n",
      "1  0.428571  0.500000  0.555556\n",
      "2  0.600000  0.636364  0.666667\n"
     ]
    }
   ],
   "source": [
    "# DataFrame 더하기\n",
    "result_add = df1 + df2\n",
    "\n",
    "# DataFrame 빼기\n",
    "result_sub = df1 - df2\n",
    "\n",
    "# DataFrame 곱하기\n",
    "result_mul = df1 * df2\n",
    "\n",
    "# DataFrame 나누기\n",
    "result_div = df1 / df2\n",
    "\n",
    "print(\"더하기 결과:\\n\", result_add)\n",
    "print(\"빼기 결과:\\n\", result_sub)\n",
    "print(\"곱하기 결과:\\n\", result_mul)\n",
    "print(\"나누기 결과:\\n\", result_div)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2-5-2. 연산 메서드 사용\n",
    "* add(), sub(), mul(), div() 등의 메서드를 사용하여 연산을 수행할 때, fill_value 매개변수를 통해 누락된 데이터에 대한 기본값을 지정할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "df3:\n",
      "    A  B\n",
      "0  0  1\n",
      "1  2  3\n",
      "\n",
      "df4:\n",
      "    B  C\n",
      "0  6  7\n",
      "1  8  9\n"
     ]
    }
   ],
   "source": [
    "df3 = DataFrame(np.arange(4).reshape(2, 2), columns=['A', 'B'])\n",
    "df4 = DataFrame(np.arange(6, 10).reshape(2, 2), columns=['B', 'C'])\n",
    "\n",
    "print(\"df3:\\n\", df3)\n",
    "print(\"\\ndf4:\\n\", df4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    A   B   C\n",
      "0 NaN   7 NaN\n",
      "1 NaN  11 NaN\n"
     ]
    }
   ],
   "source": [
    "print(df3 + df4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fill_value를 사용한 더하기 결과:\n",
      "      A   B    C\n",
      "0  0.0   7  7.0\n",
      "1  2.0  11  9.0\n"
     ]
    }
   ],
   "source": [
    "# fill_value를 사용한 더하기 연산\n",
    "result_add_fill = df3.add(df4, fill_value=0)\n",
    "\n",
    "print(\"fill_value를 사용한 더하기 결과:\\n\", result_add_fill)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2-5-3. 브로드캐스팅\n",
    "DataFrame과 Series 간 연산을 수행할 때, pandas는 기본적으로 브로드캐스팅(broadcasting) 규칙을 따릅니다. 이는 Series의 각 요소가 DataFrame의 모든 행이나 열에 대해 연산을 수행한다는 의미입니다. 주로 DataFrame의 각 행이나 각 열과 Series의 연산에 사용되며, 연산의 기준은 Series의 인덱스와 DataFrame의 컬럼 또는 인덱스에 따라 달라집니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "df:\n",
      "           b     d     e\n",
      "Utah    0.0   1.0   2.0\n",
      "Ohio    3.0   4.0   5.0\n",
      "Texas   6.0   7.0   8.0\n",
      "Oregon  9.0  10.0  11.0\n",
      "\n",
      "sr:\n",
      " b    1\n",
      "e    2\n",
      "d    3\n",
      "dtype: int64\n",
      "\n",
      "result:\n",
      "            b     d     e\n",
      "Utah     1.0   4.0   4.0\n",
      "Ohio     4.0   7.0   7.0\n",
      "Texas    7.0  10.0  10.0\n",
      "Oregon  10.0  13.0  13.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pandas import DataFrame, Series\n",
    "\n",
    "# DataFrame 생성\n",
    "df = DataFrame(\n",
    "    np.arange(12.).reshape((4, 3)), \n",
    "    columns=list('bde'), \n",
    "    index=['Utah', 'Ohio', 'Texas', 'Oregon']\n",
    ")\n",
    "\n",
    "# Series 생성\n",
    "sr = Series([1, 2, 3], index=['b', 'e', 'd'])\n",
    "\n",
    "# DataFrame의 각 행과 Series의 연산 (브로드캐스팅)\n",
    "result = df + sr\n",
    "\n",
    "print(\"df:\\n\", df)\n",
    "print(\"\\nsr:\\n\", sr)\n",
    "print(\"\\nresult:\\n\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataFrame의 각 열과 Series를 연산하려면, DataFrame의 메서드를 사용하고 axis 매개변수를 적절히 설정해야 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "sr:\n",
      " Utah      1\n",
      "Ohio      2\n",
      "Texas     3\n",
      "Oregon    4\n",
      "dtype: int64\n",
      "\n",
      "result:\n",
      "           b    d    e\n",
      "Utah   -1.0  0.0  1.0\n",
      "Ohio    1.0  2.0  3.0\n",
      "Texas   3.0  4.0  5.0\n",
      "Oregon  5.0  6.0  7.0\n"
     ]
    }
   ],
   "source": [
    "sr2 = pd.Series(\n",
    "    [1, 2, 3, 4], \n",
    "    index=['Utah', 'Ohio', 'Texas', 'Oregon']\n",
    ")\n",
    "\n",
    "# DataFrame의 각 열과 Series의 더하기 연산\n",
    "result2 = df.sub(sr2, axis='index')  # axis=0\n",
    "\n",
    "print(\"\\nsr:\\n\", sr2)\n",
    "print(\"\\nresult:\\n\", result2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2-5-4. 불리언 인덱싱\n",
    "Series와 마찬가지로 DataFrame도 불리언 인덱싱이 가능합니다.\n",
    "\n",
    "불리언 인덱싱을 사용하기 위해서는, 각 행에 대해 평가되는 조건식을 작성합니다. 이 조건식은 DataFrame의 각 행에 대해 True 또는 False 값을 갖는 불리언 시리즈를 생성합니다.\n",
    "\n",
    "이 시리즈를 DataFrame에 인덱싱으로 사용함으로써 True에 해당하는 행들만 필터링할 수 있습니다.\n",
    "##### 2-5-4-1. 단일 조건 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     name  age  salary\n",
      "1     Bob   27   54000\n",
      "3   David   32  120000\n",
      "4  Edward   29   77000\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# 예제 DataFrame 생성\n",
    "df = pd.DataFrame({\n",
    "    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Edward'],\n",
    "    'age': [24, 27, 22, 32, 29],\n",
    "    'salary': [70000, 54000, 50000, 120000, 77000]\n",
    "})\n",
    "\n",
    "# 'age'가 25보다 큰 행만 선택\n",
    "filtered_df = df[df['age'] > 25]\n",
    "\n",
    "print(filtered_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2-5-4-2. 복수 조건 사용\n",
    "복수의 조건을 함께 사용하려면 각 조건을 '()'로 감싸고, '&' (AND), '|' (OR) 연산자를 사용해 조합합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  name  age  salary\n",
      "1  Bob   27   54000\n"
     ]
    }
   ],
   "source": [
    "# 'age'가 25보다 크고 'salary'가 75000보다 적은 행만 선택\n",
    "filtered_df = df[(df['age'] > 25) & (df['salary'] < 75000)]\n",
    "\n",
    "print(filtered_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2-5-4-3. isin() 메서드 사용\n",
    "특정 컬럼의 값이 주어진 리스트 안에 있는지 확인할 때 isin() 메서드를 사용할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    name  age  salary\n",
      "0  Alice   24   70000\n",
      "3  David   32  120000\n"
     ]
    }
   ],
   "source": [
    "# 'name'이 특정 리스트 안에 있는 행만 선택\n",
    "names_to_select = ['Alice', 'David']\n",
    "filtered_df = df[df['name'].isin(names_to_select)]\n",
    "\n",
    "print(filtered_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2-5-4-4. str.contains() 메서드 사용\n",
    "특정 문자열을 포함하는 행을 선택할 때는 str.contains() 메서드를 사용할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      name  age  salary\n",
      "2  Charlie   22   50000\n",
      "3    David   32  120000\n",
      "4   Edward   29   77000\n"
     ]
    }
   ],
   "source": [
    "# 'name'에 'a'가 포함된 행만 선택\n",
    "filtered_df = df[df['name'].str.contains('a')]\n",
    "\n",
    "print(filtered_df)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}