- \n
- Introduction<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n
- Frequently Asked Questions<\/a><\/li>\n<\/ul>\n
Let’s start with a quick introduction to what the astype technique does.<\/p>\n
<\/a><\/p>\n
A Quick Introduction to Pandas Astype<\/h2>\n
The Pandas astype method modifies the datatype of Pandas objects.<\/p>\n
Frequently, we use this tool to modify the datatype of the columns of a dataframe.<\/p>\n
But there are some other ways to use it, which I’ll cover in the examples section.<\/p>\n
Most commonly, we use this technique when we clean a dataset in Python<\/a>, although there are potentially other uses for this tool during other parts of the data science workflow.<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/12\/pandas-astype_simple-visual-example.png\")
<\/p>\nYou can use the Pandas astype technique a few different ways.<\/p>\n
We can use this tool to change the datatype of:<\/p>\n
- \n
- a Pandas Series<\/li>\n
- a single column of a Pandas dataframe<\/li>\n
- multiple columns of dataframe<\/li>\n<\/ul>\n
I’ll show you examples of each of these in the examples section<\/a>.<\/p>\n
But first, let’s take a look at the syntax.<\/p>\n
<\/a><\/p>\n
The Syntax of Pandas Astype<\/h2>\n
Here, we’ll look at the syntax of the Pandas
astype()<\/code> technique.<\/p>\nSince you can use the astype technique on both dataframes and Series objects, we’ll look at the syntax for:<\/p>\n
- \n
- how to use astype on a Series<\/a><\/li>\n
- how to use astype on dataframe column(s)<\/a><\/li>\n<\/ul>\n
A quick note<\/h4>\n
Before we look at the syntax, I just want to remind you that everything else this syntax section assumes that you’ve already imported Pandas, and that you already have a Pandas dataframe or Series.<\/p>\n
You can import Pandas like this:<\/p>\n
\r\nimport pandas as pd\r\n<\/pre>\n
And there are a variety of ways to create or import dataframes. To learn more about dataframes, you can read our tutorial on Python dataframes<\/a>.<\/p>\n
<\/a><\/p>\n
syntax: use astype on a Series<\/h3>\n
First, let’s look at how to use astype on a Pandas Series.<\/p>\n
To call the method for a Series, just type the name of the series, and then use “dot syntax” to call the
astype()<\/code> method.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/12\/pandas-astype_series-syntax-explanation.png\")
<\/p>\nInside the parenthesis, you provide the name of the data type. The name of the data type should be enclosed inside quotations. For example,
astype('int16')<\/code>.<\/p>\n<\/a><\/p>\n
syntax: use astype on dataframe column(s)<\/h3>\n
Next, let’s look at how to use astype on a Python dataframe.<\/p>\n
First, you’ll type the name of the dataframe, and then use “dot syntax” to call the
astype()<\/code> method.<\/p>\nBut inside the parenthesis, instead of providing a single value as the argument, we’ll provide a dictionary<\/em>.<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/12\/pandas-astype_dataframe-syntax-explanation.png\")
<\/p>\nInside the dictionary, you provide the column name, and the datatype you want to use for the column.<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/12\/pandas-astype_dataframe-syntax-explanation_dictionary-argument.png\")
<\/p>\nYou can use this to change the datatype of a single dataframe column.<\/p>\n
But you can use this to change the datatype of multiple<\/em> columns. If you want to operate on multiple columns, simply provide several column\/datatype pairs, separated by commas, like this:<\/p>\n
\r\nyour_dataframe.astype({'column1':'datatype', 'column2':'datatype'})\r\n<\/pre>\nThis syntax enables you to operate on several dataframe columns at the same time. <\/p>\n
This is very useful for data cleaning when you have several variables that need to be modified.<\/p>\n
<\/a><\/p>\n
The parameters of Pandas astype<\/h3>\n
Now, let’s look at some of the parameters of the astype function:<\/p>\n
- \n
dtype<\/code><\/li>\ncopy<\/code><\/li>\nerrors<\/code><\/li>\n<\/ul>\ndtype<\/code> (required)<\/h6>\nThe
dtype<\/code> parameter enables you to specify the datatype.<\/p>\nIf you provide a single datatype, it will try to apply the datatype to the whole object. If you’re operating on a Series, it will convert that series to the particular datatype. But if you’re operating on a dataframe, it will try to convert every variable to that datatype (which can cause errors).<\/p>\n
Alternatively, if you’re operating on a dataframe, you can provide a dictionary as the argument to this parameter. As shown in the syntax section<\/a>, if you use this style of syntax, you can provide a dictionary of column\/datatype pairs. <\/p>\n
copy<\/code><\/h6>\nThe
copy<\/code> parameter specifies whether or not theastype<\/code> method returns a copy of the object, or operates directly on the original.<\/p>\nBy default, this parameter is set to
copy = True<\/code>. What that means is that by default, the method will return a new object (i.e., a new dataframe), and leave the original object unchanged.<\/p>\nBe careful if you set
copy = False<\/code>, because it will directly overwrite your dataset. If you do this, you need to make sure that your code works exactly as expected. <\/p>\nerrors<\/code><\/h6>\nThe
errors<\/code> parameter specifies whether the technique will raise an exception if you try to apply an inappropriate or invalid datatype to the object.<\/p>\nThe two possible arugments to this are:<\/p>\n
- \n
raise<\/code> (which will raise an exception if there is an issue)<\/li>\nignore<\/code> (which will suppress exceptions if there is an issue. If there is an error, the original object will be returned)<\/li>\n<\/ul>\nBy default this is set to
raise = True<\/code>.<\/p>\nThe output of Pandas astype<\/h3>\n
By default, the astype method will return a new object.<\/p>\n
If you’re operating on a Series, it will return a Series (with the modified datatype).<\/p>\n
If you’re operating on a dataframe, it will return a dataframe (with the modified datatype(s)).<\/p>\n
<\/a><\/p>\n
Examples: How change the datatype in a Python dataframe<\/h2>\n
Now that we’ve looked at the syntax for the Python astype function, let’s look at some examples.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Change datatype of a Pandas Series<\/a><\/li>\n
- Change the datatype of one column in a dataframe<\/a><\/li>\n
- Change the datatypes of multiple variables in a dataframe<\/a><\/li>\n<\/li>\n<\/ul>\n
Run this code first<\/h4>\n
Before you run the examples, you’ll need to:<\/p>\n
- \n
- import necessary packages<\/li>\n
- get the example dataframe<\/li>\n<\/ul>\n
Let’s do each of those.<\/p>\n
Import necessary packages<\/h5>\n
First, we need to import Pandas.<\/p>\n
You can do that with the following code:<\/p>\n
\r\nimport pandas as pd\r\n<\/pre>\n
<\/a><\/p>\n
Create example dataframe<\/h5>\n
Next, we need to create the example dataset that we’re going to work with.<\/p>\n
We’ll build the dataset with the Pandas DataFrame function, but providing it with a dictionary of column names, and some lists with the data that we want the variables to contain:<\/p>\n
\r\nsales_data = pd.DataFrame({\"name\":[\"William\",\"Emma\",\"Sofia\",\"Markus\",\"Edward\",\"Thomas\",\"Ethan\",\"Olivia\",\"Arun\",\"Anika\",\"Paulo\"]\r\n ,\"region\":[\"East\",\"North\",\"East\",\"South\",\"West\",\"West\",\"South\",\"West\",\"West\",\"East\",\"South\"]\r\n ,\"sales\":[50000,52000,90000,34000,42000,72000,49000,55000,67000,65000,67000]\r\n ,\"expenses\":[42000,43000,50000,44000,38000,39000,42000,60000,39000,44000,45000]\r\n }\r\n ,dtype = 'object'\r\n )\r\n<\/pre>\nWe’ll also create a Pandas series object, that contains only the expenses variable from the dataframe:<\/p>\n
\r\nexpenses_variable = sales_data.expenses\r\n<\/pre>\n
Let’s print out the dataframe so we can see the contents:<\/p>\n
\r\nprint(sales_data)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n name region sales expenses\r\n0 William East 50000 42000\r\n1 Emma North 52000 43000\r\n2 Sofia East 90000 50000\r\n3 Markus South 34000 44000\r\n4 Edward West 42000 38000\r\n5 Thomas West 72000 39000\r\n6 Ethan South 49000 42000\r\n7 Olivia West 55000 60000\r\n8 Arun West 67000 39000\r\n9 Anika East 65000 44000\r\n10 Paulo South 67000 45000\r\n<\/pre>\n
You can see 4 variables:<\/p>\n
- \n
name<\/code><\/li>\nregion<\/code><\/li>\nsales<\/code><\/li>\nexpenses<\/code><\/li>\n<\/ul>\nSo the dataframe contains dummy sales and expense data for several salespeople, in four different regions.<\/p>\n
Examine data types<\/h4>\n
Let’s quickly look at the data types:<\/p>\n
\r\nsales_data.dtypes\r\n<\/pre>\n
OUT:<\/p>\n
\r\nname object\r\nregion object\r\nsales object\r\nexpenses object\r\ndtype: object\r\n<\/pre>\n
Right now, all of the variables have the
object<\/code> datatype.<\/p>\nWe’ll want to change most of these.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Change Datatype of a Pandas Series<\/h3>\n
Let’s start ultra simple.<\/p>\n
Here, we’re going to use
astype()<\/code> on a Pandas series.<\/p>\nIn the section where we created our dataframe, we also separated out one of the variables into a Series called
expenses_variable<\/code>.<\/p>\nCheck initial datatype<\/h4>\n
First, let’s check the original datatype:<\/p>\n
\r\nexpenses_variable.dtype\r\n<\/pre>\n
OUT:<\/p>\n
\r\ndtype('O')\r\n<\/pre>\nThis is telling us that the Series has the ‘object’ datatype.<\/p>\n
Change datatype<\/h4>\n
Now, we’ll use Pandas astype to change the datatype to
int32<\/code>.<\/p>\n\r\nexpenses_variable.astype('int32')\r\n<\/pre>\nOUT:<\/p>\n
\r\n0 42000\r\n1 43000\r\n2 50000\r\n3 44000\r\n4 38000\r\n5 39000\r\n6 42000\r\n7 60000\r\n8 39000\r\n9 44000\r\n10 45000\r\nName: expenses, dtype: int32\r\n<\/pre>\n
Explanation<\/h5>\n
If you look carefully at the bottom of the output, you’ll see that the datatype of the output is
dtype: int32<\/code>.<\/p>\nKeep in mind: this has not<\/em> changed the
expenses_variable<\/code> directly. Theexpenses_variable<\/code> Series itself still has the ‘object’ datatype, because the output ofastype()<\/code> was sent to the console.<\/p>\nIf we wanted to directly change the data, permanently, we’d need to reassign the output back to the original variable name with the code:<\/p>\n
\r\nexpenses_variable = expenses_variable.astype('int32')\r\n<\/pre>\n<\/a><\/p>\n
EXAMPLE 2: Change the datatype of one column in a dataframe<\/h3>\n
Now, let’s operate on a column inside of a dataframe.<\/p>\n
This will be a little bit different than example 1<\/a>, where we operated on a Pandas Series.<\/p>\n
Here, we’re going to operate on a dataframe, and to do that, the syntax will be slightly different.<\/p>\n
Check initial datatype<\/h4>\n
First, let’s check the original datatypes:<\/p>\n
\r\nsales_data.dtypes\r\n<\/pre>\n
OUT:<\/p>\n
\r\nname object\r\nregion object\r\nsales object\r\nexpenses object\r\ndtype: object\r\n<\/pre>\n
You’ll notice that all of the columns have the
object<\/code> datatype.<\/p>\nChange datatype<\/h4>\n
Here, we’re going to use Pandas astype to change the data type of the
sales<\/code> column.<\/p>\n(We’re going to also use the
.dtypes<\/code> attribute to look at the data types of the output.)<\/p>\n\r\nsales_data.astype({'sales':'int32'}).dtypes\r\n<\/pre>\nOUT:<\/p>\n
\r\nname object\r\nregion object\r\nsales int32\r\nexpenses object\r\ndtype: object\r\n<\/pre>\n
Explanation<\/h5>\n
Notice that in the output, the datatype of
sales<\/code> has been changed toint32<\/code>.<\/p>\nTo do this, we called
astype<\/code>, and provided a dictionary as the argument.<\/p>\nThe dictionary contains the name of the column on the left side and on the right hand side we have the new datatype. <\/p>\n
When we use astype to operate on a full dataframe, we can use this syntax style, where we provide a dictionary with pairs for the column and datatype in the form
{'column':'data-type'}<\/code>.<\/p>\n<\/a><\/p>\n
EXAMPLE 3: Change the datatypes of multiple variables in a dataframe<\/h3>\n
Now, let’s modify the datatype of multiple columns in a dataframe.<\/p>\n
How to accomplish this will be very similar to how we modified one column in example 2<\/a> (we’ll have to use another dictionary).<\/p>\n
Check initial datatype<\/h4>\n
Again, before we perform the operation, let’s check the original datatypes:<\/p>\n
\r\nsales_data.dtypes\r\n<\/pre>\n
OUT:<\/p>\n
\r\nname object\r\nregion object\r\nsales object\r\nexpenses object\r\ndtype: object\r\n<\/pre>\n
Once again, notice that all of the columns have the
object<\/code> datatype.<\/p>\nChange datatype<\/h4>\n
Now, we’ll change the datatype of multiple columns.<\/p>\n
To do this, we’ll use a dictionary with the name of the variable and the datatype as the
'key':'value'<\/code> pairs of our dictionary.<\/p>\n(We’ll also call the
.dtypes<\/code> attribute after theastype<\/code> operation, so we can see the new datatypes)<\/p>\n\r\nsales_data.astype({'region':'category'\r\n ,'sales':'int32'\r\n ,'expenses':'int32'\r\n }\r\n ).dtypes\r\n<\/pre>\nOUT:<\/p>\n
\r\nname object\r\nregion category\r\nsales int32\r\nexpenses int32\r\ndtype: object\r\n<\/pre>\n
Explanation<\/h5>\n
Notice in the output that the datatypes of 3 columns have been changed:<\/p>\n
- \n
region<\/code> was changed tocategory<\/code><\/li>\nsales<\/code> was changed toint32<\/code><\/li>\nexpenses<\/code> was also changed toint32<\/code><\/li>\n<\/ul>\nHow did we do it?<\/p>\n
We called the astype method and inside the parenthesis, we provided a dictionary.<\/p>\n
The dictionary contained several key\/value pairs of the form
'column':'datatype'<\/code>.<\/p>\nThat’s really it … you just need to provide a dictionary with the column names and the new data types.<\/p>\n
<\/a><\/p>\n
Frequently asked questions about Pandas replace<\/h2>\n
Now that we’ve looked at some examples, let’s look at some common questions about the
replace()<\/code> technique.<\/p>\nFrequently asked questions:<\/strong><\/p>\n
- \n
- I used
astype()<\/code>, but my dataframe is unchanged. Why?<\/a><\/li>\n<\/ul>\n<\/a><\/p>\n
Question 1: I used astype, but my dataframe is unchanged. Why?<\/h3>\n
If you use the astype method, you might notice that your original dataframe remains unchanged after you call the method.<\/p>\n
For example, in example 1<\/a>, we used the following code:<\/p>\n
\r\nsales_data.astype({'sales':'int32'})\r\n<\/pre>\nBut if you check the datatypes of
sales_data<\/code> after you run the code, you’ll realize that the datatype ofsales<\/code> is unchanged.<\/p>\nThat’s because when we run the
astype()<\/code> method, it produces a new<\/em> dataframe, and leaves the original dataframe unchanged.<\/p>\nThis is how most Pandas methods work.<\/p>\n
By default, the output of the method is sent to the console. We can see the output in the console, but to save it, we need to store it with a name.<\/p>\n
For example, you could store the output like this:<\/p>\n
\r\nsales_data_updated = sales_data.astype({'sales':'int32'})\r\n<\/pre>\nYou can name the new output whatever you want. You could even name it with the original name
sales_data<\/code>. <\/p>\nJust be careful. If you reassign the output of
astype<\/code> to the original variable name, it will overwrite your original dataset. Make sure that you check your code so it works properly before you overwrite an input dataframe.<\/p>\nLeave your other questions in the comments below<\/h5>\n
Do you have any other questions about the Pandas astype method?<\/p>\n
Is there something else that you need to know that I haven’t covered here?<\/p>\n
If so, leave your question in the comments section below.<\/p>\n
Discover how to become ‘fluent’ in Pandas<\/h2>\n
This tutorial showed you how to use the Pandas astype method, but if you want to master data wrangling with Pandas, there’s a lot more to learn.<\/p>\n
So if you want to master data wrangling in Python, and become ‘fluent’ in Pandas, then you should join our course, Pandas Mastery<\/a>.<\/p>\n
Pandas Mastery is our online course that will teach you these critical data manipulation tools, show you how to memorize the syntax, and show you how to put it all together.<\/p>\n
You can find out more here:<\/p>\n
<\/p>\n
\nLearn More About Pandas Mastery<\/a>\n<\/p>\n
<\/strong><\/p>\n
\n\t\t\t\t
- Change the datatype of one column in a dataframe<\/a><\/li>\n
- how to use astype on dataframe column(s)<\/a><\/li>\n<\/ul>\n
- how to use astype on a Series<\/a><\/li>\n
- Syntax<\/a><\/li>\n