A pandas Series is a onedimensional labelled data structure which can hold data such as strings, integers and even other Python objects. It is built on top of numpy array and is the primary data structure to hold onedimensional data in pandas.
In Python, a pandas Series can be created using the constructor pandas.Series()
.
pandas.Series
Syntax

 pandas.Series(data=None, index=None, dtype=None, name=None, copy=False)
Purpose

 To create a onedimensional data structure which can store different types of data
Parameters

 data
 array or dict or scalar value or iterables (default:None). It is used to populate the rows of the Series object.
 index
 array or index (default: None). It is used to label the rows of the Series. It’s length must be the same as the object passed in the data parameter and all the values must be unique. It’s default value is ‘None’ but if the index parameter is not passed then a range of integer values from zero to one less than the total number of rows in the data object will be considered as the index.
 dtype
 String or numpy.dtype or ExtensionDtype (default: None). It is used to specify the data type of the Series which will be formed. If this parameter is not specified then the data type will be inferred from the values present in the series
 name
 String (default: None). It is used to give a name to the Series
 copy
 Boolean (default: False). It is used to copy the input data
 data
Note: If you check the offical documentation for pandas Series then another parameter called fastpath will be mentioned there. However, that parameter is an internal parameter and it cannot be actually modified by the user
How to create a pandas series from a list
A pandas Series can be created from a list by passing the list to the data parameter.
# Make a series from a list
import pandas as pd
# Create the list
data_list = ['Jeff Bezos', 'Elon Musk',
'Bernard Arnault', 'Bill Gates', 'Warren Buffett']
# pass the list to the data parameter of the series constructor
series = pd.Series(data=data_list)
series
# Output
0 Jeff Bezos
1 Elon Musk
2 Bernard Arnault
3 Bill Gates
4 Warren Buffett
dtype: object
As you can see, a pandas Series has been created from the list. Since no indices were passed, integer values from zero to one less than the total number of rows (five in this case) have been assumed as indices.
Making a series from a tuple
Creating a pandas Series from a tuple is similar to creating a Series from a list. Make the tuple which contains the required data, and then pass it to the data parameter of the series constructor.
# Create the tuple
data_tuple = tuple(
['Jeff Bezos', 'Elon Musk', 'Bernard Arnault', 'Bill Gates', 'Warren Buffett'])
# Pass the tuple to the data parameter of the series constructor
series = pd.Series(data=data_tuple)
series
#Output
0 Jeff Bezos
1 Elon Musk
2 Bernard Arnault
3 Bill Gates
4 Warren Buffett
dtype: object
Making a series from dictionaries
For creating a Series from a dictionary, the indices of the Series are formed from the keys of the dictionary, while the values of the Series are formed from the values passed to the corresponding keys of the dictionary.
After creating the dictionary, pass it to the data parameter of the series constructor to make the pandas Series.
# Make the dictionary
data_dict = {0: 'Jeff Bezos', 1: 'Elon Musk',
2: 'Bernard Arnault', 3: 'Bill Gates', 4: 'Warren Buffett'}
# Pass the dictionary to the data parameter of the series constructor
series = pd.Series(data=data_dict)
series
#Output
0 Jeff Bezos
1 Elon Musk
2 Bernard Arnault
3 Bill Gates
4 Warren Buffett
dtype: object
Making a series using numpy array
Pandas Series can also be made using Numpy arrays.
Numpy offers certain methods for creating arrays having random values or values within a specified range.
Then, these arrays can be converted to Series as well.
Creating a series from a Numpy array
For creating a Series from a Numpy array, simply pass the array to the data parameter of the series constructor.
# Create the series from array
import numpy as np
data_nparray = np.array(
['Jeff Bezos', 'Elon Musk', 'Bernard Arnault', 'Bill Gates', 'Warren Buffett'])
series = pd.Series(data=data_nparray)
series
# Output
0 Jeff Bezos
1 Elon Musk
2 Bernard Arnault
3 Bill Gates
4 Warren Buffett
dtype: object
Using the Numpy random.randn function
This function is used to create a Numpy array of specified dimensions and the array will contain random values sampled from a univariate normal distribution.
After making the array, pass it to the data parameter of the series constructor to make the Series.
# Create the numpy array
# The parameter '5' indicates that the dimensions of the arrays is (5,1)
data_nparray_random = np.random.randn(5)
# pass the array to the data parameter of the series constructor
series = pd.Series(data_nparray_random)
series
#Output
0 1.267960
1 0.814666
2 2.149895
3 1.373757
4 0.899601
dtype: float64
Using the Numpy linspace function
This function is used to create an array having values within a certain range.
After creating the array, pass the array to the data parameter of the series constructor to create the pandas Series.
# Create the array using linspace
# the first two parameters define the range and the third parameter defines the length of the array
data_nparray_linspace = np.linspace(1, 10, 5)
# pass the array to the data parameter of the series constructor
series = pd.Series(data_nparray_linspace)
series
# Output
0 1.00
1 3.25
2 5.50
3 7.75
4 10.00
dtype: float64
Using the arange function
This function is used to create Numpy arrays, which in turn will be used to create a Series having values within a certain range. The values are also spaced equally within the given range.
After creating the array using this function, pass it to the data parameter of the series constructor to create the Series.
# The first two parameters define the range while the third parameter defines
# the interval at which the values are inserted
data_arange = np.arange(1, 5, 1)
# Pass the array to the data parameter of the series constructor
series = pd.Series(data_arange)
series
# Output
0 1
1 2
2 3
3 4
dtype: int32
Using multidimensional Numpy arrays
Series can also be created using multidimensional Numpy arrays.
However, after making the multidimensional array, first convert the array into a nested list, and then pass the list to the data parameter of the series constructor.
# Create the multidimensional array
ndarray = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Convert the array to a list using the tolist method
nd_list = ndarray.tolist()
# Convert the list
nd_series = pd.Series(nd_list)
nd_list
#Output
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Creating a series using scalar value
Pandas Series can also be created by using a single scalar value.
In this case, you need to explicitly pass the indices as well in order to determine the length of the Series.
# Create series from scalar value
data = 5
# Passing the value to the data parameter of the series constructor
series = pd.Series(data, index=[0, 1, 2, 3, 4])
series
# Output
0 5
1 5
2 5
3 5
4 5
dtype: int64
Making a series with a defined index
To create a Series with a predefined index, pass the list of indices to the index parameter.
# Create series from a list and defined index.
data_list = ['Jeff Bezos', 'Elon Musk',
'Bernard Arnault', 'Bill Gates', 'Warren Bufett']
# Create the indices
indices = ['Amazon', 'Tesla', 'Louis Vuitton',
'Microsoft', 'Berkshire Hathaway']
# Pass them to the series constructor
series = pd.Series(data=data_list, index=indices)
series
#Output
Amazon Jeff Bezos
Tesla Elon Musk
Louis Vuitton Bernard Arnault
Microsoft Bill Gates
Berkshire Hathaway Warren Bufett
dtype: object
Conclusion
In this article, you saw the different ways to create a pandas Series using:
 Lists
 Tuples
 Dictionaries
 Numpy arrays
 Scalar value
 Defined index
Practical Tips
 Multidimensional Numpy arrays will first have to be converted to a list and then into a Series. The multidimensional array cannot be directly converted into a Series.
 The index values must be hashable and the same length as the object passed to the data parameter.
Test Your Knowledge
Q1: Pandas Series cannot be formed using tuples. True or False?
AnswerAnswer: False, they can be made using tuples
Q2: How is the data type of a pandas Series determined if the dtype parameter is not explicitly passed?
AnswerAnswer: The data types are inferred from the values present in the Series.
Q3: Identify the error in the given code and write the correct code:
new_series = pd.Series(data=[1,2,3,4,5,6,7,8,9],index=[1,2,3,4,5,5,6,7,8,9]
Answer:
new_series = pd.Series(data=[1,2,3,4,5,6,7,8,9],index=[1,2,3,4,5,6,7,8,9]
Q4: Write the code to make a Series from a Numpy array whose values are integers ranging from 1 to 10 using the arange function.
AnswerAnswer: pd.Series(np.arange(1,11,1))
Q5: Convert a 3×3 Numpy array whose values are the first 9 multiples of the number 9 into a pandas Series.
AnswerAnswer:`ndarray = ([[9,18,27],
[36,45,54],
[63,72,81]])
nd_list = ndarray.tolist() nd_series = pd.series(nd_list)
This article was contributed by Shreyansh.