CH03-02. Series, DataFrame 생성 및 기본 조작.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [ 3-2. Series, DataFrame 생성 및 기본 조작 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Series 생성하기\n",
    "### 1-1. 리스트를 이용한 Series 생성\n",
    "* 인덱스는 기본적으로 0부터 시작하는 정수로 자동 생성됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1\n",
      "1    2\n",
      "2    3\n",
      "3    4\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# 기본 인덱스 사용\n",
    "s1 = pd.Series([1, 2, 3, 4])\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-2. 넘파이 배열(numpy array)를 이용한 Series 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    1\n",
      "1    2\n",
      "2    3\n",
      "3    4\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "array = np.array([1, 2, 3, 4])\n",
    "s2 = pd.Series(array)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-3. 딕셔너리를 이용한 Series 생성\n",
    "* 딕셔너리의 키가 인덱스가 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "d    4\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "from pandas import Series\n",
    "\n",
    "s3 = Series({'a': 1, 'b': 2, 'c': 3, 'd': 4})\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-4. 인덱스 지정\n",
    "* Series를 생성할 때 index 매개변수를 사용하면, 데이터 각각에 해당하는 인덱스를 수동으로 지정할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    10\n",
      "b    20\n",
      "c    30\n",
      "d    40\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "s4 = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])\n",
    "print(s4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Series 객체 조회 및 값 수정\n",
    "### 2-1. Series 객체 값 조회"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    10\n",
      "b    20\n",
      "c    30\n",
      "d    40\n",
      "e    50\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "from pandas import Series\n",
    "\n",
    "s = Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "a    10\n",
      "b    20\n",
      "c    30\n",
      "dtype: int64\n",
      "d    40\n",
      "e    50\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 인덱스를 사용한 접근\n",
    "print(s['a'])  # 출력: 10\n",
    "\n",
    "# 위치를 이용한 접근\n",
    "print(s[0])    # 출력: 10\n",
    "\n",
    "# 슬라이스를 이용한 접근\n",
    "print(s[:3])   # 출력: a, b, c 인덱스의 값\n",
    "\n",
    "# 불리언 인덱싱\n",
    "print(s[s > 30])  # 30보다 큰 값들을 가진 항목들을 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-2. Series 객체 값 수정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    100\n",
      "b      0\n",
      "c    999\n",
      "d     40\n",
      "e     50\n",
      "dtype: int64\n",
      "a    100\n",
      "b    200\n",
      "c    300\n",
      "d     40\n",
      "e     50\n",
      "dtype: int64\n",
      "a      0\n",
      "b      0\n",
      "c    300\n",
      "d     40\n",
      "e     50\n",
      "dtype: int64\n",
      "a      0\n",
      "b      0\n",
      "c    999\n",
      "d     40\n",
      "e     50\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 인덱스를 사용하여 개별 값 수정\n",
    "s['a'] = 100\n",
    "print(s)\n",
    "\n",
    "# 여러 값 동시 수정 <= 여러 값을 지정할 때는 리스트나 튜플로 지정\n",
    "s[['b', 'c']] = [200, 300]\n",
    "print(s)\n",
    "\n",
    "# 슬라이스를 이용한 범위의 값 수정\n",
    "s[:2] = 0\n",
    "print(s)\n",
    "\n",
    "# 조건을 만족하는 항목 수정\n",
    "s[s > 100] = 999\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. DataFrame 생성하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-1. 리스트의 리스트를 이용한 DataFrame 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ID         Name  Age\n",
      "0   1   John Smith   32\n",
      "1   2  Diana Green   28\n",
      "2   3  Sarah Brown   45\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = [\n",
    "    [1, 'John Smith', 32],\n",
    "    [2, 'Diana Green', 28],\n",
    "    [3, 'Sarah Brown', 45]\n",
    "]\n",
    "\n",
    "df = pd.DataFrame(data, columns=['ID', 'Name', 'Age'])\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-2. 딕셔너리를 이용한 DataFrame 생성\n",
    "* 각 키가 열의 이름이 되고, 값의 리스트가 열의 데이터가 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ID         Name  Age\n",
      "0   1   John Smith   32\n",
      "1   2  Diana Green   28\n",
      "2   3  Sarah Brown   45\n"
     ]
    }
   ],
   "source": [
    "data = {\n",
    "    'ID': [1, 2, 3],\n",
    "    'Name': ['John Smith', 'Diana Green', 'Sarah Brown'],\n",
    "    'Age': [32, 28, 45]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-3. 딕셔너리의 리스트를 이용한 DataFrame 생성\n",
    "* 리스트의 각 항목이 행을 나타내는 딕셔너리 입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ID         Name  Age\n",
      "0   1   John Smith   32\n",
      "1   2  Diana Green   28\n",
      "2   3  Sarah Brown   45\n"
     ]
    }
   ],
   "source": [
    "from pandas import DataFrame\n",
    "\n",
    "data = [\n",
    "    {'ID': 1, 'Name': 'John Smith', 'Age': 32},\n",
    "    {'ID': 2, 'Name': 'Diana Green', 'Age': 28},\n",
    "    {'ID': 3, 'Name': 'Sarah Brown', 'Age': 45}\n",
    "]\n",
    "\n",
    "df = DataFrame(data)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-4. NumPy 배열을 이용한 DataFrame 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Column1   Column2   Column3\n",
      "0  0.781182  0.139754  0.255914\n",
      "1  0.977990  0.557837  0.410401\n",
      "2  0.674401  0.419973  0.492563\n",
      "3  0.969080  0.501805  0.821683\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 4x3 크기의 무작위 배열 생성\n",
    "array = np.random.rand(4, 3)\n",
    "\n",
    "df = DataFrame(array, columns=['Column1', 'Column2', 'Column3'])\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-5. Series 객체를 이용한 DataFrame 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ID         Name  Age\n",
      "0   1   John Smith   32\n",
      "1   2  Diana Green   28\n",
      "2   3  Sarah Brown   45\n"
     ]
    }
   ],
   "source": [
    "s1 = pd.Series([1, 2, 3])\n",
    "s2 = pd.Series(['John Smith', 'Diana Green', 'Sarah Brown'])\n",
    "s3 = pd.Series([32, 28, 45])\n",
    "\n",
    "df = DataFrame({'ID': s1, 'Name': s2, 'Age': s3})\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. DataFrame 객체 조회 및 값 수정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-1. 데이터 조회하기\n",
    "#### 4-1-1. 열 선택하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     John\n",
      "1     Anna\n",
      "2    Peter\n",
      "3    Linda\n",
      "Name: Name, dtype: object\n"
     ]
    }
   ],
   "source": [
    "from pandas import DataFrame\n",
    "\n",
    "# 예제 DataFrame 생성\n",
    "data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],\n",
    "        'Age': [28, 34, 29, 32],\n",
    "        'City': ['New York', 'Paris', 'Berlin', 'London']}\n",
    "df = DataFrame(data)\n",
    "\n",
    "# 'Name' 열 선택\n",
    "print(df['Name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age\n",
      "0   John   28\n",
      "1   Anna   34\n",
      "2  Peter   29\n",
      "3  Linda   32\n"
     ]
    }
   ],
   "source": [
    "# 여러 열 선택하기 : 리스트를 사용하여 선택하고자 하는 열 이름 나열\n",
    "print(df[['Name', 'Age']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4-1-2. loc, iloc 사용하기\n",
    "DataFrame의 데이터를 조회하거나 수정할 때 'loc'와 'iloc' 속성을 사용합니다. \n",
    "\n",
    "'loc'는 라벨 기반으로 데이터를 선택하며, 'iloc'는 정수 위치 기반으로 데이터를 선택합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [loc]\n",
    "* 라벨 기반 선택 : 'loc'를 사용하면 DataFrame에서 라벨을 기반으로 행이나 열을 선택할 수 있습니다. 이 때 라벨은 DataFrame의 인덱스 값(행 라벨)과 컬럼명(열 라벨)을 의미합니다.\n",
    "* 구문 : df.loc[행 라벨, 열 라벨]\n",
    "* 슬라이싱 지원 : 'loc'를 사용하여 슬라이싱을 할 때는 시작 라벨과 끝 라벨 모두 포함됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name     Anna\n",
      "Age        34\n",
      "City    Paris\n",
      "Name: 1, dtype: object\n",
      "    Name  Age\n",
      "1   Anna   34\n",
      "2  Peter   29\n",
      "Name     Linda\n",
      "Age         32\n",
      "City    London\n",
      "Name: 3, dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 'Anna'의 전체 정보 조회\n",
    "print(df.loc[1])\n",
    "\n",
    "# 'Anna'와 'Peter'의 이름과 나이 조회\n",
    "print(df.loc[1:2, ['Name', 'Age']])\n",
    "\n",
    "# 마지막 행 조회\n",
    "print(df.loc[df.index[-1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [iloc]\n",
    "* 위치 기반 선택 : 'iloc'를 사용하면 Python과 같은 방식으로 정수 위치를 기반으로 행이나 열을 선택할 수 있습니다.\n",
    "* 구문 : df.iloc[행 위치, 열 위치]\n",
    "* 슬라이싱 지원 : 'iloc'를 사용하여 슬라이싱을 할 때는 Python의 표준 슬라이싱과 같이 시작 위치는 포함되지만, 끝 위치는 포함되지 않습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "   Name  Age\n",
      "0  John   28\n",
      "1  Anna   34\n",
      "Name     Linda\n",
      "Age         32\n",
      "City    London\n",
      "Name: 3, dtype: object\n"
     ]
    }
   ],
   "source": [
    "# 첫 번째 행의 첫 번째 열(John) 조회\n",
    "print(df.iloc[0, 0])\n",
    "\n",
    "# 첫 번째와 두 번째 행의 첫 번째와 두 번째 열 조회\n",
    "print(df.iloc[0:2, 0:2])\n",
    "\n",
    "# 마지막 행 조회\n",
    "print(df.iloc[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-2. 데이터 수정하기\n",
    "#### 4-2-1. 특정 값 수정하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City\n",
      "0    Jon   28  New York\n",
      "1   Anna   34     Paris\n",
      "2  Peter   29    Berlin\n",
      "3  Linda   32    London\n"
     ]
    }
   ],
   "source": [
    "# 첫 번째 사람의 이름을 'Jon'으로 변경\n",
    "df.loc[0, 'Name'] = 'Jon'\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4-2-2. 조건에 따른 값 수정하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City\n",
      "0    Jon   28  New York\n",
      "1   Anna   34     Tokyo\n",
      "2  Peter   29    Berlin\n",
      "3  Linda   32     Tokyo\n"
     ]
    }
   ],
   "source": [
    "# 나이가 30보다 큰 사람의 도시를 'Tokyo'로 변경\n",
    "df.loc[df['Age'] > 30, 'City'] = 'Tokyo'\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4-2-3. 열에 함수 적용하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City\n",
      "0    JON   28  New York\n",
      "1   ANNA   34     Tokyo\n",
      "2  PETER   29    Berlin\n",
      "3  LINDA   32     Tokyo\n"
     ]
    }
   ],
   "source": [
    "# 모든 이름을 대문자로 변경\n",
    "df['Name'] = df['Name'].apply(lambda x: x.upper())\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4-2-4. 열 추가하기\n",
    "* 새로운 키값에 대해서 데이터 셋(리스트 등)을 설정하면 신규 데이터가 반영됨."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City Employee\n",
      "0    JON   28  New York      Yes\n",
      "1   ANNA   34     Tokyo      Yes\n",
      "2  PETER   29    Berlin       No\n",
      "3  LINDA   32     Tokyo      Yes\n"
     ]
    }
   ],
   "source": [
    "# 'Employee'라는 새 열을 추가하고, 값을 리스트로 설정함\n",
    "df['Employee'] = ['Yes', 'Yes', 'No', 'Yes']\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4-2-5. 열 삭제하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age Employee\n",
      "0    JON   28      Yes\n",
      "1   ANNA   34      Yes\n",
      "2  PETER   29       No\n",
      "3  LINDA   32      Yes\n"
     ]
    }
   ],
   "source": [
    "# 'City' 열 삭제\n",
    "df.drop('City', axis=1, inplace=True)\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* axis 매개변수가 0이면 행에, 1이면 열에 drop 메서드가 적용됩니다.\n",
    "* inplace 매개변수가 True면 원본 DataFrame이 직접 수정됩니다. 즉, 메서드가 적용된 후 DataFrame에서 지정된 행이나 열이 제거됩니다. 이 경우 반환 값은 'None' 입니다. inplace 매개변수가 False면 수정된 DataFrame을 반환하고, 원본 DataFrame은 수정되지 않습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "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.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}