class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)[source]

One-dimensional ndarray with axis labels (including time series).

Labels need not be unique but must be a hashable type. The object supports both integer- and label-based indexing and provides a host of methods for performing operations involving the index. Statistical methods from ndarray have been overridden to automatically exclude missing data (currently represented as NaN).

Operations between Series (+, -, /, , *) align values based on their associated index values– they need not be the same length. The resulting index will be the sorted union of the two indexes. Parametersdataarray-like, Iterable, dict, or scalar value

Contains data stored in Series. If data is a dict, argument order is maintained.indexarray-like or Index (1d)

Values must be hashable and have the same length as data. Non-unique index values are allowed. Will default to RangeIndex (0, 1, 2, …, n) if not provided. If data is dict-like and index is None, then the values in the index are used to reindex the Series after it is created using the keys in the data.dtypestr, numpy.dtype, or ExtensionDtype, optional

Data type for the output Series. If not specified, this will be inferred from data. See the user guide for more usages.namestr, optional

The name to give to the Series.copybool, default False

Copy input data.

Attributes

1. pandas.Series.T

property Series.T

Return the transpose, which is by definition self.

2. pandas.Series.array

property Series.array

The ExtensionArray of the data backing this Series or Index.ReturnsExtensionArray

An ExtensionArray of the values stored within. For extension types, this is the actual array. For NumPy native types, this is a thin (no copy) wrapper around numpy.ndarray.

.array differs .values which may require converting the data to a different form.

3. pandas.Series.at

property Series.at

Access a single value for a row/column label pair.

Similar to loc, in that both provide label-based lookups. Use at if you only need to get or set a single value in a DataFrame or Series.RaisesKeyError

If ‘label’ does not exist in DataFrame.

4. pandas.Series.attrs

property Series.attrs

Dictionary of global attributes of this dataset.

5. pandas.Series.axes

property Series.axes

Return a list of the row axis labels.

6.pandas.Series.dtype

property Series.dtype

Return the dtype object of the underlying data.

7.pandas.Series.dtypes

property Series.dtypes

Return the dtype object of the underlying data.

8. pandas.Series.flags

property Series.flags

Get the properties associated with this pandas object.

The available flags are

• Flags.allows_duplicate_labels

9. pandas.Series.hasnans

property Series.hasnans

Return True if there are any NaNs.

Enables various performance speedups.

10. pandas.Series.iat

property Series.iat

Access a single value for a row/column pair by integer position.

Similar to iloc, in that both provide integer-based lookups. Use iat if you only need to get or set a single value in a DataFrame or Series.RaisesIndexError

When integer position is out of bounds.

11. pandas.Series.iloc

property Series.iloc

Purely integer-location based indexing for selection by position.

.iloc[] is primarily integer position based (from 0 to length-1 of the axis), but may also be used with a boolean array.

Allowed inputs are:

• An integer, e.g. 5.
• A list or array of integers, e.g. [4, 3, 0].
• A slice object with ints, e.g. 1:7.
• A boolean array.
• A callable function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above). This is useful in method chains, when you don’t have a reference to the calling object, but would like to base your selection on some value.

.iloc will raise IndexError if a requested indexer is out-of-bounds, except slice indexers which allow out-of-bounds indexing (this conforms with python/numpy slice semantics).

12. pandas.Series.index

Series.index

The index (axis labels) of the Series.

13. pandas.Series.is_monotonic

property Series.is_monotonic

Return boolean if values in the object are monotonic_increasing.Returns bool

14. pandas.Series.is_monotonic_decreasing

property Series.is_monotonic_decreasing

Return boolean if values in the object are monotonic_decreasing.Returns bool

15. pandas.Series.is_monotonic_increasing

property Series.is_monotonic_increasing

Alias for is_monotonic.

16. pandas.Series.is_unique

property Series.is_unique

Return boolean if values in the object are unique.
Returns bool

17. pandas.Series.loc

property Series.loc

Access a group of rows and columns by label(s) or a boolean array.

.loc[] is primarily label based, but may also be used with a boolean array.

Allowed inputs are:

• A single label, e.g. 5 or 'a', (note that 5 is interpreted as a label of the index, and never as an integer position along the index).
• A list or array of labels, e.g. ['a', 'b', 'c'].
• A slice object with labels, e.g. 'a':'f'.WarningNote that contrary to usual python slices, both the start and the stop are included
• A boolean array of the same length as the axis being sliced, e.g. [True, False, True].
• An alignable boolean Series. The index of the key will be aligned before masking.
• An alignable Index. The Index of the returned selection will be the input.
• A callable function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above)

See more at Selection by Label.RaisesKeyError

If any items are not found.IndexingError

If an indexed key is passed and its index is unalignable to the frame index.

18. pandas.Series.name

property Series.name

Return the name of the Series.

The name of a Series becomes its index or column name if it is used to form a DataFrame. It is also used whenever displaying the Series using the interpreter.Returnslabel (hashable object)

The name of the Series, also the column name if part of a DataFrame.

See alsoSeries.rename

Sets the Series name when given a scalar input.Index.name

Corresponding Index property.

Examples

The Series name can be set initially when calling the constructor.

>>> s = pd.Series([1, 2, 3], dtype=np.int64, name='Numbers')
>>> s
0    1
1    2
2    3
Name: Numbers, dtype: int64
>>> s.name = "Integers"
>>> s
0    1
1    2
2    3
Name: Integers, dtype: int64

The name of a Series within a DataFrame is its column name.

>>> df = pd.DataFrame([[1, 2], [3, 4], [5, 6]],
...                   columns=["Odd Numbers", "Even Numbers"])
>>> df
   Odd Numbers  Even Numbers
0            1             2
1            3             4
2            5             6
>>> df["Even Numbers"].name
'Even Numbers'

19. pandas.Series.nbytes

property Series.nbytes

Return the number of bytes in the underlying data.

20. pandas.Series.ndim

property Series.ndim

Number of dimensions of the underlying data, by definition 1.

21. pandas.Series.shape

property Series.shape

Return a tuple of the shape of the underlying data.

22. pandas.Series.size

property Series.size

Return the number of elements in the underlying data.

23. pandas.Series.values

property Series.values

Return Series as ndarray or ndarray-like depending on the dtype.

Warning

We recommend using Series.array or Series.to_numpy(), depending on whether you need a reference to the underlying data or a NumPy array.Returnsnumpy.ndarray or ndarray-like

See alsoSeries.array

Reference to the underlying data.Series.to_numpy

A NumPy array representing the underlying data.

Examples

>>> pd.Series([1, 2, 3]).values
array([1, 2, 3])

>>> pd.Series(list('aabc')).values
array(['a', 'a', 'b', 'c'], dtype=object)

>>> pd.Series(list('aabc')).astype('category').values
['a', 'a', 'b', 'c']
Categories (3, object): ['a', 'b', 'c']

Timezone aware datetime data is converted to UTC:

>>> pd.Series(pd.date_range('20130101', periods=3,
...                         tz='US/Eastern')).values
array(['2013-01-01T05:00:00.000000000',
       '2013-01-02T05:00:00.000000000',
       '2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]')

Methods

1.pandas.Series.add

Series.add(other, level=None, fill_value=None, axis=0)[source]

Return Addition of series and other, element-wise (binary operator add).

Equivalent to series + other, but with support to substitute a fill_value for missing data in either one of the inputs.ParametersotherSeries or scalar valuefill_valueNone or float value, default None (NaN)

Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing.levelint or name

Broadcast across a level, matching Index values on the passed MultiIndex level.ReturnsSeries

The result of the operation.

See alsoSeries.radd

Reverse of the Addition operator, see Python documentation for more details.

Examples

>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a    1.0
b    1.0
c    1.0
d    NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a    1.0
b    NaN
d    1.0
e    NaN
dtype: float64
>>> a.add(b, fill_value=0)
a    2.0
b    1.0
c    1.0
d    1.0
e    NaN
dtype: float64

2.pandas.Series.add

Series.add(other, level=None, fill_value=None, axis=0)[source]

Return Addition of series and other, element-wise (binary operator add).

Equivalent to series + other, but with support to substitute a fill_value for missing data in either one of the inputs.ParametersotherSeries or scalar valuefill_valueNone or float value, default None (NaN)

Fill existing missing (NaN) values, and any new element needed for successful Series alignment, with this value before computation. If data in both corresponding Series locations is missing the result of filling (at that location) will be missing.levelint or name

Broadcast across a level, matching Index values on the passed MultiIndex level.ReturnsSeries

The result of the operation.

See alsoSeries.radd

Reverse of the Addition operator, see Python documentation for more details.

Examples

>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a    1.0
b    1.0
c    1.0
d    NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a    1.0
b    NaN
d    1.0
e    NaN
dtype: float64
>>> a.add(b, fill_value=0)
a    2.0
b    1.0
c    1.0
d    1.0
e    NaN
dtype: float64

3.pandas.Series.add_prefix

Series.add_prefix(prefix)[source]

Prefix labels with string prefix.

For Series, the row labels are prefixed. For DataFrame, the column labels are prefixed.Parametersprefixstr

The string to add before each label.ReturnsSeries or DataFrame

New Series or DataFrame with updated labels.

See alsoSeries.add_suffix

Suffix row labels with string suffix.DataFrame.add_suffix

Suffix column labels with string suffix.

Examples

>>> s = pd.Series([1, 2, 3, 4])
>>> s
0    1
1    2
2    3
3    4
dtype: int64

>>> s.add_prefix('item_')
item_0    1
item_1    2
item_2    3
item_3    4
dtype: int64

>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df
   A  B
0  1  3
1  2  4
2  3  5
3  4  6

>>> df.add_prefix('col_')
     col_A  col_B
0       1       3
1       2       4
2       3       5
3       4       6

4.pandas.Series.add_suffix

Series.add_suffix(suffix)[source]

Suffix labels with string suffix.

For Series, the row labels are suffixed. For DataFrame, the column labels are suffixed.Parameterssuffixstr

The string to add after each label.ReturnsSeries or DataFrame

New Series or DataFrame with updated labels.

See alsoSeries.add_prefix

Prefix row labels with string prefix.DataFrame.add_prefix

Prefix column labels with string prefix.

Examples

>>> s = pd.Series([1, 2, 3, 4])
>>> s
0    1
1    2
2    3
3    4
dtype: int64

>>> s.add_suffix('_item')
0_item    1
1_item    2
2_item    3
3_item    4
dtype: int64

>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df
   A  B
0  1  3
1  2  4
2  3  5
3  4  6

>>> df.add_suffix('_col')
     A_col  B_col
0       1       3
1       2       4
2       3       5
3       4       6

In this following tutorial we will learn about Chewing data Efficiently with NumPy and intelligently with SciPy and the NumPy. Let us quickly walk through some basic NumPy examples and then take a look at what SciPy provides on top of it. On the way, we will get our feet wet with plotting using the marvelous Matplotlib package.
You will fnd more interesting examples of what NumPy can offer at

    http://www.scipy.org/Tentative_NumPy_Tutorial.

You will also fnd the book NumPy Beginner’s Guide – Second Edition, Ivan Idris,Packt Publishing very valuable. Additional tutorial style guides are at http://scipy-lectures.github.com; you may also visit the offcial SciPy tutorial at http://docs.scipy.org/doc/scipy/reference/tutorial.

In this blog, we will use NumPy Version 1.6.2 and SciPy Version 0.11.0.
Learning NumPy
So let us import NumPy and play a bit with it. For that, we need to start the Python
interactive shell.

      >>> import numpy
>>> numpy.version.full_version
1.6.2

As we do not want to pollute our namespace, we certainly should not do the following:

      >>> from numpy import *

The numpy.array array will potentially shadow the array package that is included

in standard Python. Instead, we will use the following convenient shortcut:

>> import numpy as np
>>> a = np.array([0,1,2,3,4,5])
>>> a
array([0, 1, 2, 3, 4, 5])
>>> a.ndim
1
>>> a.shape
(6,)

We just created an array in a similar way to how we would create a list in Python.However, NumPy arrays have additional information about the shape. In this case,it is a one-dimensional array of fve elements. No surprises so far.

We can now transform this array in to a 2D matrix.
>>> b = a.reshape((3,2))
>>> b
array([[0, 1],
[2, 3],
[4, 5]])
>>> b.ndim
2
>>> b.shape
(3, 2)

The funny thing starts when we realize just how much the NumPy package is
optimized. For example, it avoids copies wherever possible.

>> b[1][0]=77
>>> b
array([[ 0, 1],
[77, 3],
[ 4, 5]])
>>> a
array([ 0, 1, 77, 3, 4, 5])

In this case, we have modifed the value 2 to 77 in b, and we can immediately see
the same change reflected in a as well. Keep that in mind whenever you need a
true copy.

>> c = a.reshape((3,2)).copy()
>>> c
array([[ 0, 1],
[77, 3],
[ 4, 5]])
>>> c[0][0] = -99
>>> a
array([ 0, 1, 77, 3, 4, 5])
>>> c
array([[-99, 1],
[ 77, 3],
[ 4, 5]])

Here, c and a are totally independent copies.
Another big advantage of NumPy arrays is that the operations are propagated
to the individual elements.

>> a*2
array([ 2, 4, 6, 8, 10])
>>> a**2
array([ 1, 4, 9, 16, 25])
Contrast that to ordinary Python lists:
>>> [1,2,3,4,5]*2
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> [1,2,3,4,5]**2
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: unsupported operand type(s) for ** or pow(): ‘list’ and
‘int’

Of course, by using NumPy arrays we sacrifce the agility Python lists offer. Simple
operations like adding or removing are a bit complex for NumPy arrays. Luckily,
we have both at our disposal, and we will use the right one for the task at hand.
Indexing

Part of the power of NumPy comes from the versatile ways in which its arrays can
be accessed.
In addition to normal list indexing, it allows us to use arrays themselves as indices.

>> a[np.array([2,3,4])]
array([77, 3, 4])
In addition to the fact that conditions are now propagated to the individual elements,
we gain a very convenient way to access our data.
>>> a>4
array([False, False, True, False, False, True], dtype=bool)
>>> a[a>4]
array([77, 5])
This can also be used to trim outliers.
>>> a[a>4] = 4
>>> a
array([0, 1, 4, 3, 4, 4])

As this is a frequent use case, there is a special clip function for it, clipping the values
at both ends of an interval with one function call as follows:

>> a.clip(0,4)
array([0, 1, 4, 3, 4, 4])

 

Handling non-existing values
The power of NumPy’s indexing capabilities comes in handy when pre processing data that we have just read in from a text fle. It will most likely contain invalid values, which we will mark as not being a real number using numpy.NAN as follows:

c = np.array([1, 2, np.NAN, 3, 4]) # let’s pretend we have read this
from a text file
>>> c
array([ 1., 2., nan, 3., 4.])
>>> np.isnan(c)
array([False, False, True, False, False], dtype=bool)
>>> c[~np.isnan(c)]
array([ 1., 2., 3., 4.])
>>> np.mean(c[~np.isnan(c)])
2.5

Comparing runtime behaviors Let us compare the runtime behavior of NumPy with normal Python lists. In the
ollowing code, we will calculate the sum of all squared numbers of 1 to 1000 and see how much time the calculation will take. We do it 10000 times and report the total time so that our measurement is accurate enough.

import timeit
normal_py_sec = timeit.timeit(‘sum(x*x for x in xrange(1000))’,
number=10000)
naive_np_sec = timeit.timeit(‘sum(na*na)’,
setup=”import numpy as np; na=np.
arange(1000)”,
number=10000)
good_np_sec = timeit.timeit(‘na.dot(na)’,
setup=”import numpy as np; na=np.
arange(1000)”,
number=10000)
print(“Normal Python: %f sec”%normal_py_sec)
print(“Naive NumPy: %f sec”%naive_np_sec)
print(“Good NumPy: %f sec”%good_np_sec)
Normal Python: 1.157467 sec
Naive NumPy: 4.061293 sec
Good NumPy: 0.033419 sec

We make two interesting observations. First, just using NumPy as data storage (Naive NumPy) takes 3.5 times longer, which is surprising since we believe it must be much faster as it is written as a C extension. One reason for this is that the access of individual elements from Python itself is rather costly. Only when we are able to apply algorithms inside the optimized extension code do we get speed improvements, and
tremendous ones at that: using the dot() function of NumPy, we are more than 25 times faster. In summary, in every algorithm we are about to implement, we should always look at how we can move loops over individual elements from Python to some of the highly optimized NumPy or SciPy extension functions.

However, the speed comes at a price. Using NumPy arrays, we no longer have the incredible flexibility of Python lists, which can hold basically anything. NumPy arrays always have only one datatype.
>>> a = np.array([1,2,3])
>>> a.dtype
dtype(‘int64’)
If we try to use elements of different types, NumPy will do its best to coerce them to the most reasonable common datatype:
>>> np.array([1, “stringy”])
array([‘1’, ‘stringy’], dtype=’|S8′)
>>> np.array([1, “stringy”, set([1,2,3])])
array([1, stringy, set([1, 2, 3])], dtype=object)

Machine learning (ML)  teaches machines how to carry out tasks by themselves.It is that simple. The complexity comes with the details, and that is most likely the
reason you are reading this Machine learning and Python blog Series.
Maybe you have too much data and too little insight, and you hoped that using
machine learning algorithms will help you solve this challenge. So you started to
dig into random algorithms. But after some time you were puzzled: which of the
myriad of algorithms should you actually choose?
Or maybe you are broadly interested in machine learning and have been reading
a few blogs and articles about it for some time. Everything seemed to be magic and
cool, so you started your exploration and fed some toy data into a decision tree or
a support vector machine. But after you successfully applied it to some other data,
you wondered, was the whole setting right? Did you get the optimal results? And
how do you know there are no better algorithms? Or whether your data was “the
right one”?
Welcome to the club! We, the authors, were at those stages once upon a time,
looking for information that tells the real story behind the theoretical textbooks
on machine learning. It turned out that much of that information was “black art”,
not usually taught in standard textbooks. So, in a sense, we wrote this book to our
younger selves; a book that not only gives a quick introduction to machine learning,
but also teaches you lessons that we have learned along the way. We hope that it
will also give you, the reader, a smoother entry into one of the most exciting fields
in Computer Science.