2886. Change Data Type

Problem Description

The given problem presents a data structure scenario, where we have a DataFrame named students consisting of several columns: student_id, name, age, and grade. The student_id is of type integer, name is an object (which usually means string in this context), age is an integer, and the grade is a float. The task at hand is to convert the data type of the grade column from float to integer. The conversion should be reflected in the students DataFrame, and the updated DataFrame should be returned as an output.


In this solution, the focus is to implement a type conversion of one column within a DataFrame using the Pandas library in Python. The motivation behind the solution is the need to standardize or comply with a certain data format requirement. The column grade is initially in a floating-point (decimal) format, which might be more precise than needed. The goal is to transform this column to an integer format, which can be easier to handle for certain computations or when presenting the data.

We arrive at the solution approach by recognizing that Pandas provides a very direct and efficient method to change the data type of a DataFrame column using the astype function. This is a common operation when dealing with DataFrames as part of data cleaning and preprocessing. The solution simply involves taking the grade column and applying the astype(int) method, which converts the data type from float to integer and it truncates any decimal portion in the process (e.g., 73.0 becomes 73). The modified column replaces the original grade column in the DataFrame, and the updated DataFrame is then returned.

Not Sure What to Study? Take the 2-min Quiz to Find Your Missing Piece:

The three-steps of Depth First Search are:

  1. Identify states;
  2. Draw the state-space tree;
  3. DFS on the state-space tree.

Solution Approach

The implementation of the solution relies on the Pandas library, which is a powerful and flexible tool for data manipulation in Python. The primary components of Pandas used here are DataFrames, which are two-dimensional data structures with labeled axes (rows and columns). DataFrames allow you to store and manipulate tabular data where the manipulation includes operations like filtering, grouping, and, as required by our problem, type conversion of columns.

The solution provided follows these steps:

  1. The astype function is invoked on the grade column of the students DataFrame. The astype function is a built-in pandas function specifically designed for type conversion of series-like data structures.
  2. The argument passed to astype is int, which indicates the desired target data type for the grade column.
  3. The result of the astype function, which is a Series with the grade data converted to integers, replaces the original grade column within the students DataFrame.
  4. The updated students DataFrame, now with the grade column containing integer types, is returned from the function.

This method is effective and efficient because:

  • Data Integrity: Using astype(int) ensures that all the values will be converted to integers, as long as they can be represented as such. If a value cannot be converted (for example, a non-numeric string or NaN values in the column), astype would raise an error, alerting the user to the presence of incompatible data.
  • Simplicity: The astype method is straightforward to use and doesn't require writing a custom conversion function or loop, making the code cleaner and more readable.
  • Performance: Since astype is a method provided by Pandas, it is heavily optimized and can convert types very quickly, even for large datasets.

Consequently, this specific problem does not introduce algorithmic complexity. It is an application of a Pandas function that abstracts away the complexity of type conversion. The focus is more on understanding how to use the library function rather than implementing an algorithm from scratch.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:

Which of the following is the prefix sum of array [1, 2, 3, 4, 5]?

Example Walkthrough

Let's suppose we have a small DataFrame named students with the following data:

1  student_id     name  age  grade
20           1    Alice   17   89.5
31           2      Bob   18   91.3
42           3  Charlie   17   78.0
53           4    Diana   18   72.8

We aim to convert the grade column from float to integer data type.

Here's an illustrative example of the solution approach:

  1. We initially have the grade column with float data types, which in our example are 89.5, 91.3, 78.0, and 72.8.
  2. We apply the astype(int) function on the grade column. The DataFrame manipulation looks like this in code:
    1students['grade'] = students['grade'].astype(int)
  3. After applying the astype(int) function, the floating-point numbers are truncated to integers, which means, for instance, 89.5 would become 89, and 72.8 would become 72.
  4. Our students DataFrame is now updated. The grade column data type is changed from float to integer, resulting in the following DataFrame:
1  student_id     name  age  grade
20           1    Alice   17     89
31           2      Bob   18     91
42           3  Charlie   17     78
53           4    Diana   18     72

This method efficiently achieves the conversion of the entire column without the need for iterating over each row, which is both simpler and more performant, especially with large data sets.

Solution Implementation

1import pandas as pd
3def change_datatype(students: pd.DataFrame) -> pd.DataFrame:
4    """
5    Convert the datatype of the 'grade' column to integer.
7    Parameters:
8    students (pd.DataFrame): A DataFrame with a 'grade' column.
10    Returns:
11    pd.DataFrame: The updated DataFrame with the 'grade' column as integers.
12    """
13    # Assuming 'grade' column originally contains values that can be directly converted to integers
14    students['grade'] = students['grade'].astype(int)
15    return students
1import java.util.List;
2import java.util.Map;
4public class DataConverter {
6    // Method to change the datatype of the 'grade' column to Integer
7    public static List<Map<String, Object>> changeDatatype(List<Map<String, Object>> students) {
8        // Iterate over each record (i.e., map) in the list
9        for (Map<String, Object> student : students) {
10            // Assuming that the grades are stored as strings that can be parsed to integers
11            String gradeAsString = (String) student.get("grade");
12            // Convert the 'grade' string to an integer and update the map record
13            int gradeAsInt = Integer.parseInt(gradeAsString);
14            student.put("grade", gradeAsInt);
15        }
16        // Return the updated list of records with the 'grade' column as integers
17        return students;
18    }
20    // The main method for testing the changeDatatype method
21    public static void main(String[] args) {
22        // You would initialize your List<Map<String, Object>> here and pass it to the changeDatatype method
23        // List<Map<String, Object>> students = ...
24        // List<Map<String, Object>> studentsWithIntGrades = changeDatatype(students);
26        // Implement the test logic here, such as printing the updated list to verify the 'grade' column data type
27    }
1#include <vector>
2#include <iostream>
4// For simplicity, the following struct represents a student record.
5struct Student {
6    std::string name;
7    int grade; // Here, we're assuming 'grade' will be stored as integer.
10// Accept a vector of Student records and update the 'grade' field to integer if necessary.
11std::vector<Student> changeDatatype(std::vector<Student> students) {
12    // Assuming each student's grade is in a valid format that can be directly interpreted as an integer.
13    // Hence, no actual conversion is performed in C++ because 'grade' is already an integer.
14    // If a conversion was needed, we would need to parse the string to integer using std::stoi, for example.
16    // Return the updated list of students.
17    return students;
20// Example usage:
21int main() {
22    // Create a vector of Student records.
23    std::vector<Student> students = {{"Alice", 90}, {"Bob", 85}, {"Charlie", 92}};
25    // Call the function to ensure grades are in integer datatype.
26    students = changeDatatype(students);
28    // Printing the students to show the result (grades are already integers; this will just print them out).
29    for(const auto& student : students) {
30        std::cout << "Student Name: " << student.name << ", Grade: " << student.grade << std::endl;
31    }
33    return 0;
1// Assuming that we have some global type definitions similar to Pandas DataFrame structure
3// Define an interface to represent the structure of our students object.
4interface StudentRecord {
5    // Other properties for students would be defined here.
6    grade: string; // Initially the grade is a string
9// Define a type alias for an array of student records, mimicking DataFrame
10type DataFrame = StudentRecord[];
12// Function to change the datatype of the 'grade' property to a number
13function changeDatatype(students: DataFrame): DataFrame {
14    // Convert the 'grade' property of each student record from a string to an integer
15    students.forEach((student) => {
16        student.grade = parseInt(student.grade);
17    });
19    // Return the updated students array with 'grade' property as integers.
20    return students;
Not Sure What to Study? Take the 2-min Quiz:

What is the running time of the following code?

1int sqrt(int n) {
2  for (int guess = 1; guess * guess <= n; guess++) {
3    if (guess * guess == n) {
4      return guess;
5    }
6  }
7  return -1;

Time and Space Complexity

The time complexity of the changeDatatype function primarily depends on the time it takes to change the data type of the 'grade' column in the pandas DataFrame. When using astype(int), pandas internally iterates over each element to convert it to an integer. Therefore, the time complexity is O(n), where n is the number of elements in the 'grade' column.

The space complexity of the operation depends on whether pandas optimizes the memory usage by modifying the data in place or by creating a copy. Since the current behavior of pandas suggests that a new array is often made, we might consider the space complexity to be O(n) as well, where n is the number of elements in the 'grade' column. However, it's worth noting that the real behavior can vary based on the pandas' version and internal optimizations that may occur.

Fast Track Your Learning with Our Quick Skills Quiz:

Which two pointer techniques do you use to check if a string is a palindrome?

Recommended Readings

Got a question? Ask the Teaching Assistant anything you don't understand.

Still not clear? Ask in the Forum,  Discord or Submit the part you don't understand to our editors.

TA 👨‍🏫