Day64 - Pandas Interview Questions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Pandas Interview Questions**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `1. What is Pandas, and why is it popular in data analyst?`\n",
    "\n",
    "\n",
    "Pandas is a popular open-source data manipulation and analysis library for the Python programming language. It provides data structures for efficiently storing and manipulating large datasets and tools for reading and writing data in various formats. The two primary data structures in Pandas are:\n",
    "\n",
    "1. **Series:** A one-dimensional labeled array capable of holding any data type.\n",
    "2. **DataFrame:** A two-dimensional labeled data structure with columns that can be of different types.\n",
    "\n",
    "Pandas is widely used in the field of data analysis for several reasons:\n",
    "\n",
    "1. **Ease of Use:** Pandas provides a simple and intuitive syntax for data manipulation. Its data structures are designed to be easy to use and interact with.\n",
    "\n",
    "2. **Data Cleaning and Transformation:** Pandas makes it easy to clean and transform data. It provides functions for handling missing data, reshaping data, merging and joining datasets, and performing various data transformations.\n",
    "\n",
    "3. **Data Exploration:** Pandas allows data analysts to explore and understand their datasets quickly. Descriptive statistics, data summarization, and various methods for slicing and dicing data are readily available.\n",
    "\n",
    "4. **Data Input/Output:** Pandas supports reading and writing data in various formats, including CSV, Excel, SQL databases, and more. This makes it easy to work with data from different sources.\n",
    "\n",
    "5. **Integration with Other Libraries:** Pandas integrates well with other popular data science and machine learning libraries in Python, such as NumPy, Matplotlib, and Scikit-learn. This allows for a seamless workflow when performing more complex analyses.\n",
    "\n",
    "6. **Time Series Analysis:** Pandas provides excellent support for time series data, including tools for date range generation, frequency conversion, and resampling.\n",
    "\n",
    "7. **Community and Documentation:** Pandas has a large and active community, which means there is extensive documentation and a wealth of online resources, tutorials, and forums available for users to seek help and guidance.\n",
    "\n",
    "8. **Open Source:** Being an open-source project, Pandas allows users to contribute to its development and improvement. This collaborative nature has helped Pandas evolve and stay relevant in the rapidly changing landscape of data analysis and data science.\n",
    "\n",
    "In summary, Pandas is popular in data analysis because it simplifies the process of working with structured data, provides powerful tools for data manipulation, and has become a standard tool in the Python ecosystem for data analysis tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `2. What is DataFrame in Pandas?`\n",
    "\n",
    "In Pandas, a DataFrame is a two-dimensional, tabular data structure with labeled axes (rows and columns). It is similar to a spreadsheet or SQL table, where data can be stored in rows and columns. The key features of a DataFrame include:\n",
    "\n",
    "1. **Tabular Structure:** A DataFrame is a two-dimensional table with rows and columns. Each column can have a different data type, such as integer, float, string, or even custom types.\n",
    "\n",
    "2. **Labeled Axes:** Both rows and columns of a DataFrame are labeled. This means that each row and each column has a unique label or index associated with it, allowing for easy access and manipulation of data.\n",
    "\n",
    "3. **Flexible Size:** DataFrames can grow and shrink in size. You can add or remove rows and columns as needed.\n",
    "\n",
    "4. **Heterogeneous Data Types:** Different columns in a DataFrame can have different data types. For example, one column might contain integers, while another column contains strings.\n",
    "\n",
    "5. **Data Alignment:** When performing operations on DataFrames, Pandas automatically aligns the data based on labels, making it easy to work with data even if it is not perfectly clean or aligned.\n",
    "\n",
    "6. **Missing Data Handling:** DataFrames can handle missing data gracefully. Pandas provides methods for detecting, removing, or filling missing values.\n",
    "\n",
    "7. **Powerful Operations:** DataFrames support a wide range of operations, including arithmetic operations, aggregation, filtering, merging, and reshaping. This makes it a powerful tool for data analysis and manipulation.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Name  Age           City\n",
      "0  John   28       New York\n",
      "1  Jane   24  San Francisco\n",
      "2   Bob   22    Los Angeles\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Creating a DataFrame from a dictionary\n",
    "data = {'Name': ['John', 'Jane', 'Bob'],\n",
    "        'Age': [28, 24, 22],\n",
    "        'City': ['New York', 'San Francisco', 'Los Angeles']}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Displaying the DataFrame\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, each column represents a different attribute (Name, Age, City), and each row represents a different individual. The DataFrame provides a convenient way to work with this tabular data in a structured and labeled format."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `3. What is diffrence between loc and iloc  in pandas?`\n",
    "\n",
    "In Pandas, `loc` and `iloc` are two different methods used for indexing and selecting data from a DataFrame. They are primarily used for label-based and integer-location-based indexing, respectively. Here's the key difference between `loc` and `iloc`:\n",
    "\n",
    "1. **`loc` (Label-based Indexing):**\n",
    "   - The `loc` method is used for selection by label.\n",
    "   - It allows you to access a group of rows and columns by labels or a boolean array.\n",
    "   - The syntax is `df.loc[row_label, column_label]` or `df.loc[row_label]` for selecting entire rows.\n",
    "   - The labels used with `loc` are the actual labels of the index or column names, not the integer position.\n",
    "   - Inclusive slicing is supported with `loc`, meaning both the start and stop index are included in the selection.\n",
    "\n",
    "   \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "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>Name</th>\n",
       "      <th>Age</th>\n",
       "      <th>City</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Bob</td>\n",
       "      <td>22</td>\n",
       "      <td>Los Angeles</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Name  Age         City\n",
       "2  Bob   22  Los Angeles"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "   # Assuming 'df' is our DataFrame\n",
    "selected_data = df.loc[2:4, 'Name':'City']\n",
    "selected_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **`iloc` (Integer-location based Indexing):**\n",
    "   - The `iloc` method is used for selection by position.\n",
    "   - It allows you to access a group of rows and columns by integer positions.\n",
    "   - The syntax is `df.iloc[row_index, column_index]` or `df.iloc[row_index]` for selecting entire rows.\n",
    "   - The indices used with `iloc` are integer-based, meaning you specify the position of the rows and columns based on their numerical order (0-based indexing).\n",
    "   - Exclusive slicing is used with `iloc`, meaning the stop index is not included in the selection.\n",
    "\n",
    "   \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "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>Name</th>\n",
       "      <th>Age</th>\n",
       "      <th>City</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Bob</td>\n",
       "      <td>22</td>\n",
       "      <td>Los Angeles</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Name  Age         City\n",
       "2  Bob   22  Los Angeles"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "   # Assuming 'df' is our DataFrame\n",
    "selected_data = df.iloc[2:5, 0:3]\n",
    "selected_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In summary, if you want to select data based on the labels of rows and columns, you use `loc`. If you prefer to select data based on the integer positions of rows and columns, you use `iloc`. The choice between them depends on whether you are working with labeled or integer-based indexing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `4. How do you filter rows in a dataframe based on condition?`\n",
    "\n",
    "To filter rows in a DataFrame based on a condition, you can use boolean indexing. Boolean indexing involves creating a boolean Series that represents the condition you want to apply and then using that boolean Series to filter the rows of the DataFrame. Here's a step-by-step guide:\n",
    "\n",
    "Assuming you have a DataFrame named df, and you want to filter rows based on a condition, let's say a condition on the 'Age' column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Name  Age      City\n",
      "0   John   28  New York\n",
      "3  Alice   30   Chicago\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Assuming 'df' is your DataFrame\n",
    "data = {'Name': ['John', 'Jane', 'Bob', 'Alice'],\n",
    "        'Age': [28, 24, 22, 30],\n",
    "        'City': ['New York', 'San Francisco', 'Los Angeles', 'Chicago']}\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Condition for filtering (e.g., selecting rows where Age is greater than 25)\n",
    "condition = df['Age'] > 25\n",
    "\n",
    "# Applying the condition to filter rows\n",
    "filtered_df = df[condition]\n",
    "\n",
    "# Displaying the filtered DataFrame\n",
    "print(filtered_df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `5. How do you handle missing values in data with the help of pandas?`\n",
    "\n",
    "Handling missing values is a crucial step in the data cleaning process. Pandas provides several methods for working with missing data in a DataFrame. Here are some common techniques:\n",
    "\n",
    "1. **Detecting Missing Values:**\n",
    "   - The `isnull()` method can be used to detect missing values in a DataFrame. It returns a DataFrame of the same shape, where each element is a boolean indicating whether the corresponding element in the original DataFrame is missing.\n",
    "   - The `notnull()` method is the opposite of `isnull()` and returns `True` for non-missing values.\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Assuming 'df' is your DataFrame\n",
    "missing_values = df.isnull()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Dropping Missing Values:**\n",
    "   - The `dropna()` method can be used to remove rows or columns containing missing values.\n",
    "   - The `thresh` parameter can be used to specify a threshold for the number of non-null values required to keep a row or column.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop rows with any missing values\n",
    "df_no_missing_rows = df.dropna()\n",
    "\n",
    "# Drop columns with any missing values\n",
    "df_no_missing_cols = df.dropna(axis=1)\n",
    "\n",
    "# Drop rows with at least 3 non-null values\n",
    "df_thresh = df.dropna(thresh=3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **Filling Missing Values:**\n",
    "   - The `fillna()` method can be used to fill missing values with a specified constant or using various filling methods like forward fill or backward fill.\n",
    "   - Commonly, mean or median values are used to fill missing values in numerical columns.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fill missing values with a constant\n",
    "df_fill_constant = df.fillna(0)\n",
    "\n",
    "# Fill missing values with the mean of the column\n",
    "df_fill_mean = df.fillna(df.mean())\n",
    "\n",
    "# Forward fill missing values (use the previous value)\n",
    "df_ffill = df.fillna(method='ffill')\n",
    "\n",
    "# Backward fill missing values (use the next value)\n",
    "df_bfill = df.fillna(method='bfill')\n"
   ]
  }
 ],
 "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}