Informatics Practices: Class 12 — Chapter 2: Data Handling Using Pandas - I

1. A NumPy array requires homogeneous data, whereas a Pandas DataFrame can store heterogeneous data types (e.g., float, int, string, datetime).
2. Pandas provides a simpler interface for operations like file loading, plotting, selection, joining, and grouping ( GROUP BY ).
3. Pandas DataFrames use explicit column names, making data tracking highly intuitive.
4. Pandas is optimized for tabular data formats, while NumPy is designed for low-level numeric array-based manipulations.

Pandas can be installed via the command line using the Python package installer:

  
  pip install pandas

Note: Both NumPy and Pandas require Python to be pre-installed on the system.

A data structure is a collection of data values and operations that can be applied to that data, enabling efficient storage, retrieval, and modification. Pandas primarily uses two data structures:

• Series: A one-dimensional array-like structure.
• DataFrame: A two-dimensional tabular structure.

To create or use a Series, the Pandas library must first be imported:

  
  import pandas as pd

(A) Creation of Series from Scalar Values:

  
    >>> series1 = pd.Series([10, 20, 30])
    >>> print(series1)
    0    10
    1    20
    2    30
    dtype: int64
  

(B) Creation of Series with User-Defined Indices:

  
    >>> series2 = pd.Series(["Kavi", "Shyam", "Ravi"], index=[3, 5, 1])
    >>> print(series2)
    3     Kavi
    5    Shyam
    1     Ravi
    dtype: object
  

(C) Creation of Series from NumPy Arrays:

  
    >>> import numpy as np
    >>> array1 = np.array([1, 2, 3, 4])
    >>> series3 = pd.Series(array1)
    >>> print(series3)
    0    1
    1    2
    2    3
    3    4
    dtype: int32
  

Note: If index labels are passed with a NumPy array, the length of the index and the array must match, otherwise a ValueError is raised.

(D) Creation of Series from a Dictionary:

  
    >>> dict1 = {'India': 'NewDelhi', 'UK': 'London', 'Japan': 'Tokyo'}
    >>> series8 = pd.Series(dict1)
    >>> print(series8)
    India    NewDelhi
    UK         London
    Japan       Tokyo
    dtype: object
  

Elements of a Series can be accessed using two primary methods: Indexing and Slicing .

(A) Indexing:

• Positional Index: Uses integer values corresponding to the position starting from 0.
• Labelled Index: Uses user-defined labels.

  
    >>> seriesNum = pd.Series([10, 20, 30])
    >>> seriesNum[2]
    30
  

Accessing multiple elements using a list of indices:

  
    >>> seriesCapCntry[['UK', 'USA']]
    UK           London
    USA    WashingtonDC
    dtype: object
  

(B) Slicing:

Slicing extracts a subset of a Series using the syntax [start:end] .

• Positional Slicing: Excludes the end index value (i.e., extracts up to end - 1 ).
• Labelled Slicing: Includes the end index value.

  
    >>> seriesCapCntry[1:3]
    USA    WashingtonDC
    UK           London
    dtype: object
    >>> seriesCapCntry['USA':'France']
    USA       WashingtonDC
    UK              London
    France           Paris
    dtype: object
  

Reversing a Series using slicing:

  
  >>> seriesCapCntry[::-1]

The following table details the core attributes of a Pandas Series:

Mathematical operations on Series align data based on index labels. If an index is present in one Series but not the other, the resulting value is marked as NaN (Not a Number).

Using Operators vs Methods:

• Operators ( + , - , * , / ): Perform operations but result in NaN for missing indices.
• Methods ( add() , sub() , mul() , div() ): Allow the use of the fill_value parameter to replace missing values before calculation.

  
    >>> # Addition with operator
    >>> seriesA + seriesB
    a     -9.0
    b      NaN
    c    -47.0
    >>> # Addition with method and fill_value
    >>> seriesA.add(seriesB, fill_value=0)
    a     -9.0
    b      2.0
    c    -47.0
  

DataFrames can be created from various inputs:

• Empty DataFrame: pd.DataFrame()
• NumPy ndarrays:

    
    >>> dFrame = pd.DataFrame([array1, array2], columns=['A', 'B', 'C', 'D'])
  
  

• List of Dictionaries: Keys become column labels; missing keys are filled with NaN .

    
      >>> listDict = [{'a': 10, 'b': 20}, {'a': 5, 'b': 10, 'c': 20}]
      >>> dFrame = pd.DataFrame(listDict)
    
  

• Dictionary of Lists: Keys become column labels, and lists become column values.

    
      >>> dictForest = {'State': ['Assam', 'Delhi'], 'GArea': [78438, 1483]}
      >>> dFrame = pd.DataFrame(dictForest)
    
  

• Dictionary of Series:

    
    >>> dFrame = pd.DataFrame({'Series1': seriesA, 'Series2': seriesB})
  
  

• Adding a Column:

      
      >>> ResultDF['Preeti'] = [89, 78, 76]
    
  

• Adding a Row (using .loc[] ):

    
    >>> ResultDF.loc['English'] = [85, 86, 83, 80, 90, 89]
  
  

• Deleting Rows or Columns (using .drop() ):

  Use axis=0 for rows and axis=1 for columns.

    
      >>> ResultDF = ResultDF.drop('Science', axis=0) # Drops row
      >>> ResultDF = ResultDF.drop(['Samridhi', 'Riya'], axis=1) # Drops columns
    
  

• Renaming Labels (using .rename() ):

    
      >>> ResultDF = ResultDF.rename({'Maths': 'Sub1'}, axis='index')
      >>> ResultDF = ResultDF.rename({'Arnab': 'Student1'}, axis='columns')
    
  

• Label-Based Indexing ( .loc[] ):

    
      >>> ResultDF.loc['Science'] # Accesses a row as a Series
      >>> ResultDF.loc[:, 'Arnab'] # Accesses a column as a Series
    
  

• Boolean Indexing: Filters data based on conditions.

    
    >>> ResultDF.loc['Maths'] > 90
  
  

• Slicing: Slicing in DataFrames is inclusive of both start and end values.

    
    >>> ResultDF.loc['Maths':'Science', 'Arnab':'Samridhi']
  
  

The .append() method is used to append rows of one DataFrame to another.

Key Parameters:

• sort=True : Sorts column labels alphabetically.
• verify_integrity=True : Raises an error if there are duplicate row labels.
• ignore_index=True : Re-indexes the resulting DataFrame from 0 to N-1.

  
  >>> dFrame1 = dFrame1.append(dFrame2, ignore_index=True)

The read_csv() function loads data from a CSV file into a DataFrame.

  
  >>> marks = pd.read_csv("C:/NCERT/ResultData.csv", sep=",", header=0)

Parameters:

• sep : Specifies the delimiter (default is comma).
• header : Specifies the row number to use as column names (default is 0).
• names : Allows custom column names to be passed as a list.

The to_csv() method writes a DataFrame to a CSV or \text file.

  
  >>> ResultDF.to_csv('C:/NCERT/resultout.csv', sep=',', index=False)

Parameters:

• index=False : Prevents row index labels from being written to the file.
• header=False : Prevents column headers from being written to the file.