`__. The ``box``
+method is applicable on the air quality example data:
+
+.. ipython:: python
+
+ @savefig 04_airqual_boxplot.png
+ air_quality.plot.box()
+
+.. raw:: html
+
+
+ To user guide
+
+For an introduction to plots other than the default line plot, see the user guide section about :ref:`supported plot styles `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ -
+
+I want each of the columns in a separate subplot.
+
+.. ipython:: python
+
+ @savefig 04_airqual_area_subplot.png
+ axs = air_quality.plot.area(figsize=(12, 4), subplots=True)
+
+Separate subplots for each of the data columns is supported by the ``subplots`` argument
+of the ``plot`` functions. The builtin options available in each of the pandas plot
+functions that are worthwhile to have a look.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+Some more formatting options are explained in the user guide section on :ref:`plot formatting `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ -
+
+I want to further customize, extend or save the resulting plot.
+
+.. ipython:: python
+
+ fig, axs = plt.subplots(figsize=(12, 4));
+ air_quality.plot.area(ax=axs);
+ @savefig 04_airqual_customized.png
+ axs.set_ylabel("NO$_2$ concentration");
+ fig.savefig("no2_concentrations.png")
+
+.. ipython:: python
+ :suppress:
+
+ import os
+ os.remove('no2_concentrations.png')
+
+.. raw:: html
+
+
+
+
+Each of the plot objects created by pandas are a
+`matplotlib `__ object. As Matplotlib provides
+plenty of options to customize plots, making the link between pandas and
+Matplotlib explicit enables all the power of matplotlib to the plot.
+This strategy is applied in the previous example:
+
+::
+
+ fig, axs = plt.subplots(figsize=(12, 4)) # Create an empty matplotlib Figure and Axes
+ air_quality.plot.area(ax=axs) # Use pandas to put the area plot on the prepared Figure/Axes
+ axs.set_ylabel("NO$_2$ concentration") # Do any matplotlib customization you like
+ fig.savefig("no2_concentrations.png") # Save the Figure/Axes using the existing matplotlib method.
+
+.. raw:: html
+
+
+
REMEMBER
+
+- The ``.plot.*`` methods are applicable on both Series and DataFrames
+- By default, each of the columns is plotted as a different element
+ (line, boxplot,…)
+- Any plot created by pandas is a Matplotlib object.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+A full overview of plotting in pandas is provided in the :ref:`visualization pages `.
+
+.. raw:: html
+
+
diff --git a/doc/source/getting_started/intro_tutorials/05_add_columns.rst b/doc/source/getting_started/intro_tutorials/05_add_columns.rst
new file mode 100644
index 0000000000000..d4f6a8d6bb4a2
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/05_add_columns.rst
@@ -0,0 +1,186 @@
+.. _10min_tut_05_columns:
+
+{{ header }}
+
+.. ipython:: python
+
+ import pandas as pd
+
+.. raw:: html
+
+
+
+
+ -
+
+ Air quality data
+
+
+
+
+
+For this tutorial, air quality data about :math:`NO_2` is used, made
+available by `openaq `__ and using the
+`py-openaq `__ package.
+The ``air_quality_no2.csv`` data set provides :math:`NO_2` values for
+the measurement stations *FR04014*, *BETR801* and *London Westminster*
+in respectively Paris, Antwerp and London.
+
+.. raw:: html
+
+
+
To raw data
+
+
+
+
+ -
+
+I want to express the :math:`NO_2` concentration of the station in London in mg/m\ :math:`^3`
+
+(*If we assume temperature of 25 degrees Celsius and pressure of 1013
+hPa, the conversion factor is 1.882*)
+
+.. ipython:: python
+
+ air_quality["london_mg_per_cubic"] = air_quality["station_london"] * 1.882
+ air_quality.head()
+
+To create a new column, use the ``[]`` brackets with the new column name
+at the left side of the assignment.
+
+.. raw:: html
+
+
+
+
+.. note::
+ The calculation of the values is done **element_wise**. This
+ means all values in the given column are multiplied by the value 1.882
+ at once. You do not need to use a loop to iterate each of the rows!
+
+.. image:: ../../_static/schemas/05_newcolumn_2.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+I want to check the ratio of the values in Paris versus Antwerp and save the result in a new column
+
+.. ipython:: python
+
+ air_quality["ratio_paris_antwerp"] = \
+ air_quality["station_paris"] / air_quality["station_antwerp"]
+ air_quality.head()
+
+The calculation is again element-wise, so the ``/`` is applied *for the
+values in each row*.
+
+.. raw:: html
+
+
+
+
+Also other mathematical operators (+, -, \*, /) or
+logical operators (<, >, =,…) work element wise. The latter was already
+used in the :ref:`subset data tutorial <10min_tut_03_subset>` to filter
+rows of a table using a conditional expression.
+
+.. raw:: html
+
+
+ -
+
+I want to rename the data columns to the corresponding station identifiers used by openAQ
+
+.. ipython:: python
+
+ air_quality_renamed = air_quality.rename(
+ columns={"station_antwerp": "BETR801",
+ "station_paris": "FR04014",
+ "station_london": "London Westminster"})
+
+.. ipython:: python
+
+ air_quality_renamed.head()
+
+The :meth:`~DataFrame.rename` function can be used for both row labels and column
+labels. Provide a dictionary with the keys the current names and the
+values the new names to update the corresponding names.
+
+.. raw:: html
+
+
+
+
+The mapping should not be restricted to fixed names only, but can be a
+mapping function as well. For example, converting the column names to
+lowercase letters can be done using a function as well:
+
+.. ipython:: python
+
+ air_quality_renamed = air_quality_renamed.rename(columns=str.lower)
+ air_quality_renamed.head()
+
+.. raw:: html
+
+
+ To user guide
+
+Details about column or row label renaming is provided in the user guide section on :ref:`renaming labels `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+
REMEMBER
+
+- Create a new column by assigning the output to the DataFrame with a
+ new column name in between the ``[]``.
+- Operations are element-wise, no need to loop over rows.
+- Use ``rename`` with a dictionary or function to rename row labels or
+ column names.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+The user guide contains a separate section on :ref:`column addition and deletion `.
+
+.. raw:: html
+
+
diff --git a/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst b/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst
new file mode 100644
index 0000000000000..7a94c90525027
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/06_calculate_statistics.rst
@@ -0,0 +1,310 @@
+.. _10min_tut_06_stats:
+
+{{ header }}
+
+.. ipython:: python
+
+ import pandas as pd
+
+.. raw:: html
+
+
+
+
+ -
+
+ Titanic data
+
+
+
+
+
+This tutorial uses the titanic data set, stored as CSV. The data
+consists of the following data columns:
+
+- PassengerId: Id of every passenger.
+- Survived: This feature have value 0 and 1. 0 for not survived and 1
+ for survived.
+- Pclass: There are 3 classes: Class 1, Class 2 and Class 3.
+- Name: Name of passenger.
+- Sex: Gender of passenger.
+- Age: Age of passenger.
+- SibSp: Indication that passenger have siblings and spouse.
+- Parch: Whether a passenger is alone or have family.
+- Ticket: Ticket number of passenger.
+- Fare: Indicating the fare.
+- Cabin: The cabin of passenger.
+- Embarked: The embarked category.
+
+.. raw:: html
+
+
+
To raw data
+
+
+
+
+ -
+
+What is the average age of the titanic passengers?
+
+.. ipython:: python
+
+ titanic["Age"].mean()
+
+.. raw:: html
+
+
+
+
+Different statistics are available and can be applied to columns with
+numerical data. Operations in general exclude missing data and operate
+across rows by default.
+
+.. image:: ../../_static/schemas/06_reduction.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+What is the median age and ticket fare price of the titanic passengers?
+
+.. ipython:: python
+
+ titanic[["Age", "Fare"]].median()
+
+The statistic applied to multiple columns of a ``DataFrame`` (the selection of two columns
+return a ``DataFrame``, see the :ref:`subset data tutorial <10min_tut_03_subset>`) is calculated for each numeric column.
+
+.. raw:: html
+
+
+
+
+The aggregating statistic can be calculated for multiple columns at the
+same time. Remember the ``describe`` function from :ref:`first tutorial <10min_tut_01_tableoriented>` tutorial?
+
+.. ipython:: python
+
+ titanic[["Age", "Fare"]].describe()
+
+Instead of the predefined statistics, specific combinations of
+aggregating statistics for given columns can be defined using the
+:func:`DataFrame.agg` method:
+
+.. ipython:: python
+
+ titanic.agg({'Age': ['min', 'max', 'median', 'skew'],
+ 'Fare': ['min', 'max', 'median', 'mean']})
+
+.. raw:: html
+
+
+ To user guide
+
+Details about descriptive statistics are provided in the user guide section on :ref:`descriptive statistics `.
+
+.. raw:: html
+
+
+
+
+Aggregating statistics grouped by category
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. image:: ../../_static/schemas/06_groupby.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+What is the average age for male versus female titanic passengers?
+
+.. ipython:: python
+
+ titanic[["Sex", "Age"]].groupby("Sex").mean()
+
+As our interest is the average age for each gender, a subselection on
+these two columns is made first: ``titanic[["Sex", "Age"]]``. Next, the
+:meth:`~DataFrame.groupby` method is applied on the ``Sex`` column to make a group per
+category. The average age *for each gender* is calculated and
+returned.
+
+.. raw:: html
+
+
+
+
+Calculating a given statistic (e.g. ``mean`` age) *for each category in
+a column* (e.g. male/female in the ``Sex`` column) is a common pattern.
+The ``groupby`` method is used to support this type of operations. More
+general, this fits in the more general ``split-apply-combine`` pattern:
+
+- **Split** the data into groups
+- **Apply** a function to each group independently
+- **Combine** the results into a data structure
+
+The apply and combine steps are typically done together in pandas.
+
+In the previous example, we explicitly selected the 2 columns first. If
+not, the ``mean`` method is applied to each column containing numerical
+columns:
+
+.. ipython:: python
+
+ titanic.groupby("Sex").mean()
+
+It does not make much sense to get the average value of the ``Pclass``.
+if we are only interested in the average age for each gender, the
+selection of columns (rectangular brackets ``[]`` as usual) is supported
+on the grouped data as well:
+
+.. ipython:: python
+
+ titanic.groupby("Sex")["Age"].mean()
+
+.. image:: ../../_static/schemas/06_groupby_select_detail.svg
+ :align: center
+
+.. note::
+ The `Pclass` column contains numerical data but actually
+ represents 3 categories (or factors) with respectively the labels ‘1’,
+ ‘2’ and ‘3’. Calculating statistics on these does not make much sense.
+ Therefore, pandas provides a ``Categorical`` data type to handle this
+ type of data. More information is provided in the user guide
+ :ref:`categorical` section.
+
+.. raw:: html
+
+
+ -
+
+What is the mean ticket fare price for each of the sex and cabin class combinations?
+
+.. ipython:: python
+
+ titanic.groupby(["Sex", "Pclass"])["Fare"].mean()
+
+Grouping can be done by multiple columns at the same time. Provide the
+column names as a list to the :meth:`~DataFrame.groupby` method.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+A full description on the split-apply-combine approach is provided in the user guide section on :ref:`groupby operations `.
+
+.. raw:: html
+
+
+
+Count number of records by category
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. image:: ../../_static/schemas/06_valuecounts.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+What is the number of passengers in each of the cabin classes?
+
+.. ipython:: python
+
+ titanic["Pclass"].value_counts()
+
+The :meth:`~Series.value_counts` method counts the number of records for each
+category in a column.
+
+.. raw:: html
+
+
+
+
+The function is a shortcut, as it is actually a groupby operation in combination with counting of the number of records
+within each group:
+
+.. ipython:: python
+
+ titanic.groupby("Pclass")["Pclass"].count()
+
+.. note::
+ Both ``size`` and ``count`` can be used in combination with
+ ``groupby``. Whereas ``size`` includes ``NaN`` values and just provides
+ the number of rows (size of the table), ``count`` excludes the missing
+ values. In the ``value_counts`` method, use the ``dropna`` argument to
+ include or exclude the ``NaN`` values.
+
+.. raw:: html
+
+
+ To user guide
+
+The user guide has a dedicated section on ``value_counts`` , see page on :ref:`discretization `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+
REMEMBER
+
+- Aggregation statistics can be calculated on entire columns or rows
+- ``groupby`` provides the power of the *split-apply-combine* pattern
+- ``value_counts`` is a convenient shortcut to count the number of
+ entries in each category of a variable
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+A full description on the split-apply-combine approach is provided in the user guide pages about :ref:`groupby operations `.
+
+.. raw:: html
+
+
diff --git a/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst b/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst
new file mode 100644
index 0000000000000..b28a9012a4ad9
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/07_reshape_table_layout.rst
@@ -0,0 +1,404 @@
+.. _10min_tut_07_reshape:
+
+{{ header }}
+
+.. ipython:: python
+
+ import pandas as pd
+
+.. raw:: html
+
+
+
+
+ -
+
+ Titanic data
+
+
+
+
+
+This tutorial uses the titanic data set, stored as CSV. The data
+consists of the following data columns:
+
+- PassengerId: Id of every passenger.
+- Survived: This feature have value 0 and 1. 0 for not survived and 1
+ for survived.
+- Pclass: There are 3 classes: Class 1, Class 2 and Class 3.
+- Name: Name of passenger.
+- Sex: Gender of passenger.
+- Age: Age of passenger.
+- SibSp: Indication that passenger have siblings and spouse.
+- Parch: Whether a passenger is alone or have family.
+- Ticket: Ticket number of passenger.
+- Fare: Indicating the fare.
+- Cabin: The cabin of passenger.
+- Embarked: The embarked category.
+
+.. raw:: html
+
+
+
To raw data
+
+
+ -
+
+ Air quality data
+
+
+
+
+
+This tutorial uses air quality data about :math:`NO_2` and Particulate matter less than 2.5
+micrometers, made available by
+`openaq `__ and using the
+`py-openaq `__ package.
+The ``air_quality_long.csv`` data set provides :math:`NO_2` and
+:math:`PM_{25}` values for the measurement stations *FR04014*, *BETR801*
+and *London Westminster* in respectively Paris, Antwerp and London.
+
+The air-quality data set has the following columns:
+
+- city: city where the sensor is used, either Paris, Antwerp or London
+- country: country where the sensor is used, either FR, BE or GB
+- location: the id of the sensor, either *FR04014*, *BETR801* or
+ *London Westminster*
+- parameter: the parameter measured by the sensor, either :math:`NO_2`
+ or Particulate matter
+- value: the measured value
+- unit: the unit of the measured parameter, in this case ‘µg/m³’
+
+and the index of the ``DataFrame`` is ``datetime``, the datetime of the
+measurement.
+
+.. note::
+ The air-quality data is provided in a so-called *long format*
+ data representation with each observation on a separate row and each
+ variable a separate column of the data table. The long/narrow format is
+ also known as the `tidy data
+ format `__.
+
+.. raw:: html
+
+
+
To raw data
+
+
+
+
+ -
+
+I want to sort the titanic data according to the age of the passengers.
+
+.. ipython:: python
+
+ titanic.sort_values(by="Age").head()
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ -
+
+I want to sort the titanic data according to the cabin class and age in descending order.
+
+.. ipython:: python
+
+ titanic.sort_values(by=['Pclass', 'Age'], ascending=False).head()
+
+With :meth:`Series.sort_values`, the rows in the table are sorted according to the
+defined column(s). The index will follow the row order.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+More details about sorting of tables is provided in the using guide section on :ref:`sorting data `.
+
+.. raw:: html
+
+
+
+Long to wide table format
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Let’s use a small subset of the air quality data set. We focus on
+:math:`NO_2` data and only use the first two measurements of each
+location (i.e. the head of each group). The subset of data will be
+called ``no2_subset``
+
+.. ipython:: python
+
+ # filter for no2 data only
+ no2 = air_quality[air_quality["parameter"] == "no2"]
+
+.. ipython:: python
+
+ # use 2 measurements (head) for each location (groupby)
+ no2_subset = no2.sort_index().groupby(["location"]).head(2)
+ no2_subset
+
+.. image:: ../../_static/schemas/07_pivot.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+I want the values for the three stations as separate columns next to each other
+
+.. ipython:: python
+
+ no2_subset.pivot(columns="location", values="value")
+
+The :meth:`~pandas.pivot_table` function is purely reshaping of the data: a single value
+for each index/column combination is required.
+
+.. raw:: html
+
+
+
+
+As pandas support plotting of multiple columns (see :ref:`plotting tutorial <10min_tut_04_plotting>`) out of the box, the conversion from
+*long* to *wide* table format enables the plotting of the different time
+series at the same time:
+
+.. ipython:: python
+
+ no2.head()
+
+.. ipython:: python
+
+ @savefig 7_reshape_columns.png
+ no2.pivot(columns="location", values="value").plot()
+
+.. note::
+ When the ``index`` parameter is not defined, the existing
+ index (row labels) is used.
+
+.. raw:: html
+
+
+ To user guide
+
+For more information about :meth:`~DataFrame.pivot`, see the user guide section on :ref:`pivoting DataFrame objects `.
+
+.. raw:: html
+
+
+
+Pivot table
+~~~~~~~~~~~
+
+.. image:: ../../_static/schemas/07_pivot_table.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+I want the mean concentrations for :math:`NO_2` and :math:`PM_{2.5}` in each of the stations in table form
+
+.. ipython:: python
+
+ air_quality.pivot_table(values="value", index="location",
+ columns="parameter", aggfunc="mean")
+
+In the case of :meth:`~DataFrame.pivot`, the data is only rearranged. When multiple
+values need to be aggregated (in this specific case, the values on
+different time steps) :meth:`~DataFrame.pivot_table` can be used, providing an
+aggregation function (e.g. mean) on how to combine these values.
+
+.. raw:: html
+
+
+
+
+Pivot table is a well known concept in spreadsheet software. When
+interested in summary columns for each variable separately as well, put
+the ``margin`` parameter to ``True``:
+
+.. ipython:: python
+
+ air_quality.pivot_table(values="value", index="location",
+ columns="parameter", aggfunc="mean",
+ margins=True)
+
+.. raw:: html
+
+
+ To user guide
+
+For more information about :meth:`~DataFrame.pivot_table`, see the user guide section on :ref:`pivot tables `.
+
+.. raw:: html
+
+
+
+.. note::
+ If case you are wondering, :meth:`~DataFrame.pivot_table` is indeed directly linked
+ to :meth:`~DataFrame.groupby`. The same result can be derived by grouping on both
+ ``parameter`` and ``location``:
+
+ ::
+
+ air_quality.groupby(["parameter", "location"]).mean()
+
+.. raw:: html
+
+
+ To user guide
+
+Have a look at :meth:`~DataFrame.groupby` in combination with :meth:`~DataFrame.unstack` at the user guide section on :ref:`combining stats and groupby `.
+
+.. raw:: html
+
+
+
+Wide to long format
+~~~~~~~~~~~~~~~~~~~
+
+Starting again from the wide format table created in the previous
+section:
+
+.. ipython:: python
+
+ no2_pivoted = no2.pivot(columns="location", values="value").reset_index()
+ no2_pivoted.head()
+
+.. image:: ../../_static/schemas/07_melt.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+I want to collect all air quality :math:`NO_2` measurements in a single column (long format)
+
+.. ipython:: python
+
+ no_2 = no2_pivoted.melt(id_vars="date.utc")
+ no_2.head()
+
+The :func:`pandas.melt` method on a ``DataFrame`` converts the data table from wide
+format to long format. The column headers become the variable names in a
+newly created column.
+
+.. raw:: html
+
+
+
+
+The solution is the short version on how to apply :func:`pandas.melt`. The method
+will *melt* all columns NOT mentioned in ``id_vars`` together into two
+columns: A columns with the column header names and a column with the
+values itself. The latter column gets by default the name ``value``.
+
+The :func:`pandas.melt` method can be defined in more detail:
+
+.. ipython:: python
+
+ no_2 = no2_pivoted.melt(id_vars="date.utc",
+ value_vars=["BETR801",
+ "FR04014",
+ "London Westminster"],
+ value_name="NO_2",
+ var_name="id_location")
+ no_2.head()
+
+The result in the same, but in more detail defined:
+
+- ``value_vars`` defines explicitly which columns to *melt* together
+- ``value_name`` provides a custom column name for the values column
+ instead of the default columns name ``value``
+- ``var_name`` provides a custom column name for the columns collecting
+ the column header names. Otherwise it takes the index name or a
+ default ``variable``
+
+Hence, the arguments ``value_name`` and ``var_name`` are just
+user-defined names for the two generated columns. The columns to melt
+are defined by ``id_vars`` and ``value_vars``.
+
+.. raw:: html
+
+
+ To user guide
+
+Conversion from wide to long format with :func:`pandas.melt` is explained in the user guide section on :ref:`reshaping by melt `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+
REMEMBER
+
+- Sorting by one or more columns is supported by ``sort_values``
+- The ``pivot`` function is purely restructering of the data,
+ ``pivot_table`` supports aggregations
+- The reverse of ``pivot`` (long to wide format) is ``melt`` (wide to
+ long format)
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+A full overview is available in the user guide on the pages about :ref:`reshaping and pivoting `.
+
+.. raw:: html
+
+
diff --git a/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst b/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst
new file mode 100644
index 0000000000000..f317e7a1f91b4
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/08_combine_dataframes.rst
@@ -0,0 +1,326 @@
+.. _10min_tut_08_combine:
+
+{{ header }}
+
+.. ipython:: python
+
+ import pandas as pd
+
+.. raw:: html
+
+
+
+
+How to combine data from multiple tables?
+-----------------------------------------
+
+Concatenating objects
+~~~~~~~~~~~~~~~~~~~~~
+
+.. image:: ../../_static/schemas/08_concat_row.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+I want to combine the measurements of :math:`NO_2` and :math:`PM_{25}`, two tables with a similar structure, in a single table
+
+.. ipython:: python
+
+ air_quality = pd.concat([air_quality_pm25, air_quality_no2], axis=0)
+ air_quality.head()
+
+The :func:`~pandas.concat` function performs concatenation operations of multiple
+tables along one of the axis (row-wise or column-wise).
+
+.. raw:: html
+
+
+
+
+By default concatenation is along axis 0, so the resulting table combines the rows
+of the input tables. Let’s check the shape of the original and the
+concatenated tables to verify the operation:
+
+.. ipython:: python
+
+ print('Shape of the `air_quality_pm25` table: ', air_quality_pm25.shape)
+ print('Shape of the `air_quality_no2` table: ', air_quality_no2.shape)
+ print('Shape of the resulting `air_quality` table: ', air_quality.shape)
+
+Hence, the resulting table has 3178 = 1110 + 2068 rows.
+
+.. note::
+ The **axis** argument will return in a number of pandas
+ methods that can be applied **along an axis**. A ``DataFrame`` has two
+ corresponding axes: the first running vertically downwards across rows
+ (axis 0), and the second running horizontally across columns (axis 1).
+ Most operations like concatenation or summary statistics are by default
+ across rows (axis 0), but can be applied across columns as well.
+
+Sorting the table on the datetime information illustrates also the
+combination of both tables, with the ``parameter`` column defining the
+origin of the table (either ``no2`` from table ``air_quality_no2`` or
+``pm25`` from table ``air_quality_pm25``):
+
+.. ipython:: python
+
+ air_quality = air_quality.sort_values("date.utc")
+ air_quality.head()
+
+In this specific example, the ``parameter`` column provided by the data
+ensures that each of the original tables can be identified. This is not
+always the case. the ``concat`` function provides a convenient solution
+with the ``keys`` argument, adding an additional (hierarchical) row
+index. For example:
+
+.. ipython:: python
+
+ air_quality_ = pd.concat([air_quality_pm25, air_quality_no2],
+ keys=["PM25", "NO2"])
+
+.. ipython:: python
+
+ air_quality_.head()
+
+.. note::
+ The existence of multiple row/column indices at the same time
+ has not been mentioned within these tutorials. *Hierarchical indexing*
+ or *MultiIndex* is an advanced and powerfull pandas feature to analyze
+ higher dimensional data.
+
+ Multi-indexing is out of scope for this pandas introduction. For the
+ moment, remember that the function ``reset_index`` can be used to
+ convert any level of an index to a column, e.g.
+ ``air_quality.reset_index(level=0)``
+
+ .. raw:: html
+
+
+
To user guide
+
+ Feel free to dive into the world of multi-indexing at the user guide section on :ref:`advanced indexing
`.
+
+ .. raw:: html
+
+
+ To user guide
+
+More options on table concatenation (row and column
+wise) and how ``concat`` can be used to define the logic (union or
+intersection) of the indexes on the other axes is provided at the section on
+:ref:`object concatenation `.
+
+.. raw:: html
+
+
+
+Join tables using a common identifier
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. image:: ../../_static/schemas/08_merge_left.svg
+ :align: center
+
+.. raw:: html
+
+
+ -
+
+Add the station coordinates, provided by the stations metadata table, to the corresponding rows in the measurements table.
+
+.. warning::
+ The air quality measurement station coordinates are stored in a data
+ file ``air_quality_stations.csv``, downloaded using the
+ `py-openaq `__ package.
+
+.. ipython:: python
+
+ stations_coord = pd.read_csv("data/air_quality_stations.csv")
+ stations_coord.head()
+
+.. note::
+ The stations used in this example (FR04014, BETR801 and London
+ Westminster) are just three entries enlisted in the metadata table. We
+ only want to add the coordinates of these three to the measurements
+ table, each on the corresponding rows of the ``air_quality`` table.
+
+.. ipython:: python
+
+ air_quality.head()
+
+.. ipython:: python
+
+ air_quality = pd.merge(air_quality, stations_coord,
+ how='left', on='location')
+ air_quality.head()
+
+Using the :meth:`~pandas.merge` function, for each of the rows in the
+``air_quality`` table, the corresponding coordinates are added from the
+``air_quality_stations_coord`` table. Both tables have the column
+``location`` in common which is used as a key to combine the
+information. By choosing the ``left`` join, only the locations available
+in the ``air_quality`` (left) table, i.e. FR04014, BETR801 and London
+Westminster, end up in the resulting table. The ``merge`` function
+supports multiple join options similar to database-style operations.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ -
+
+Add the parameter full description and name, provided by the parameters metadata table, to the measurements table
+
+.. warning::
+ The air quality parameters metadata are stored in a data file
+ ``air_quality_parameters.csv``, downloaded using the
+ `py-openaq `__ package.
+
+.. ipython:: python
+
+ air_quality_parameters = pd.read_csv("data/air_quality_parameters.csv")
+ air_quality_parameters.head()
+
+.. ipython:: python
+
+ air_quality = pd.merge(air_quality, air_quality_parameters,
+ how='left', left_on='parameter', right_on='id')
+ air_quality.head()
+
+Compared to the previous example, there is no common column name.
+However, the ``parameter`` column in the ``air_quality`` table and the
+``id`` column in the ``air_quality_parameters_name`` both provide the
+measured variable in a common format. The ``left_on`` and ``right_on``
+arguments are used here (instead of just ``on``) to make the link
+between the two tables.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+pandas supports also inner, outer, and right joins.
+More information on join/merge of tables is provided in the user guide section on
+:ref:`database style merging of tables `. Or have a look at the
+:ref:`comparison with SQL` page.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+
REMEMBER
+
+- Multiple tables can be concatenated both column as row wise using
+ the ``concat`` function.
+- For database-like merging/joining of tables, use the ``merge``
+ function.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+See the user guide for a full description of the various :ref:`facilities to combine data tables `.
+
+.. raw:: html
+
+
diff --git a/doc/source/getting_started/intro_tutorials/09_timeseries.rst b/doc/source/getting_started/intro_tutorials/09_timeseries.rst
new file mode 100644
index 0000000000000..d5b4b316130bb
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/09_timeseries.rst
@@ -0,0 +1,389 @@
+.. _10min_tut_09_timeseries:
+
+{{ header }}
+
+.. ipython:: python
+
+ import pandas as pd
+ import matplotlib.pyplot as plt
+
+.. raw:: html
+
+
+
+
+ -
+
+ Air quality data
+
+
+
+
+
+For this tutorial, air quality data about :math:`NO_2` and Particulate
+matter less than 2.5 micrometers is used, made available by
+`openaq `__ and downloaded using the
+`py-openaq `__ package.
+The ``air_quality_no2_long.csv"`` data set provides :math:`NO_2` values
+for the measurement stations *FR04014*, *BETR801* and *London
+Westminster* in respectively Paris, Antwerp and London.
+
+.. raw:: html
+
+
+
To raw data
+
+
+
+
+ -
+
+I want to work with the dates in the column ``datetime`` as datetime objects instead of plain text
+
+.. ipython:: python
+
+ air_quality["datetime"] = pd.to_datetime(air_quality["datetime"])
+ air_quality["datetime"]
+
+Initially, the values in ``datetime`` are character strings and do not
+provide any datetime operations (e.g. extract the year, day of the
+week,…). By applying the ``to_datetime`` function, pandas interprets the
+strings and convert these to datetime (i.e. ``datetime64[ns, UTC]``)
+objects. In pandas we call these datetime objects similar to
+``datetime.datetime`` from the standard library a :class:`pandas.Timestamp`.
+
+.. raw:: html
+
+
+
+
+.. note::
+ As many data sets do contain datetime information in one of
+ the columns, pandas input function like :func:`pandas.read_csv` and :func:`pandas.read_json`
+ can do the transformation to dates when reading the data using the
+ ``parse_dates`` parameter with a list of the columns to read as
+ Timestamp:
+
+ ::
+
+ pd.read_csv("../data/air_quality_no2_long.csv", parse_dates=["datetime"])
+
+Why are these :class:`pandas.Timestamp` objects useful. Let’s illustrate the added
+value with some example cases.
+
+ What is the start and end date of the time series data set working
+ with?
+
+.. ipython:: python
+
+ air_quality["datetime"].min(), air_quality["datetime"].max()
+
+Using :class:`pandas.Timestamp` for datetimes enable us to calculate with date
+information and make them comparable. Hence, we can use this to get the
+length of our time series:
+
+.. ipython:: python
+
+ air_quality["datetime"].max() - air_quality["datetime"].min()
+
+The result is a :class:`pandas.Timedelta` object, similar to ``datetime.timedelta``
+from the standard Python library and defining a time duration.
+
+.. raw:: html
+
+
+ To user guide
+
+The different time concepts supported by pandas are explained in the user guide section on :ref:`time related concepts `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ -
+
+I want to add a new column to the ``DataFrame`` containing only the month of the measurement
+
+.. ipython:: python
+
+ air_quality["month"] = air_quality["datetime"].dt.month
+ air_quality.head()
+
+By using ``Timestamp`` objects for dates, a lot of time-related
+properties are provided by pandas. For example the ``month``, but also
+``year``, ``weekofyear``, ``quarter``,… All of these properties are
+accessible by the ``dt`` accessor.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+An overview of the existing date properties is given in the
+:ref:`time and date components overview table `. More details about the ``dt`` accessor
+to return datetime like properties is explained in a dedicated section on the :ref:`dt accessor `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ -
+
+What is the average :math:`NO_2` concentration for each day of the week for each of the measurement locations?
+
+.. ipython:: python
+
+ air_quality.groupby(
+ [air_quality["datetime"].dt.weekday, "location"])["value"].mean()
+
+Remember the split-apply-combine pattern provided by ``groupby`` from the
+:ref:`tutorial on statistics calculation <10min_tut_06_stats>`?
+Here, we want to calculate a given statistic (e.g. mean :math:`NO_2`)
+**for each weekday** and **for each measurement location**. To group on
+weekdays, we use the datetime property ``weekday`` (with Monday=0 and
+Sunday=6) of pandas ``Timestamp``, which is also accessible by the
+``dt`` accessor. The grouping on both locations and weekdays can be done
+to split the calculation of the mean on each of these combinations.
+
+.. danger::
+ As we are working with a very short time series in these
+ examples, the analysis does not provide a long-term representative
+ result!
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ -
+
+Plot the typical :math:`NO_2` pattern during the day of our time series of all stations together. In other words, what is the average value for each hour of the day?
+
+.. ipython:: python
+
+ fig, axs = plt.subplots(figsize=(12, 4))
+ air_quality.groupby(
+ air_quality["datetime"].dt.hour)["value"].mean().plot(kind='bar',
+ rot=0,
+ ax=axs)
+ plt.xlabel("Hour of the day"); # custom x label using matplotlib
+ @savefig 09_bar_chart.png
+ plt.ylabel("$NO_2 (µg/m^3)$");
+
+Similar to the previous case, we want to calculate a given statistic
+(e.g. mean :math:`NO_2`) **for each hour of the day** and we can use the
+split-apply-combine approach again. For this case, the datetime property ``hour``
+of pandas ``Timestamp``, which is also accessible by the ``dt`` accessor.
+
+.. raw:: html
+
+
+
+
+Datetime as index
+~~~~~~~~~~~~~~~~~
+
+In the :ref:`tutorial on reshaping <10min_tut_07_reshape>`,
+:meth:`~pandas.pivot` was introduced to reshape the data table with each of the
+measurements locations as a separate column:
+
+.. ipython:: python
+
+ no_2 = air_quality.pivot(index="datetime", columns="location", values="value")
+ no_2.head()
+
+.. note::
+ By pivoting the data, the datetime information became the
+ index of the table. In general, setting a column as an index can be
+ achieved by the ``set_index`` function.
+
+Working with a datetime index (i.e. ``DatetimeIndex``) provides powerful
+functionalities. For example, we do not need the ``dt`` accessor to get
+the time series properties, but have these properties available on the
+index directly:
+
+.. ipython:: python
+
+ no_2.index.year, no_2.index.weekday
+
+Some other advantages are the convenient subsetting of time period or
+the adapted time scale on plots. Let’s apply this on our data.
+
+.. raw:: html
+
+
+ -
+
+Create a plot of the :math:`NO_2` values in the different stations from the 20th of May till the end of 21st of May
+
+.. ipython:: python
+ :okwarning:
+
+ @savefig 09_time_section.png
+ no_2["2019-05-20":"2019-05-21"].plot();
+
+By providing a **string that parses to a datetime**, a specific subset of the data can be selected on a ``DatetimeIndex``.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+More information on the ``DatetimeIndex`` and the slicing by using strings is provided in the section on :ref:`time series indexing `.
+
+.. raw:: html
+
+
+
+Resample a time series to another frequency
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: html
+
+
+ -
+
+Aggregate the current hourly time series values to the monthly maximum value in each of the stations.
+
+.. ipython:: python
+
+ monthly_max = no_2.resample("M").max()
+ monthly_max
+
+A very powerful method on time series data with a datetime index, is the
+ability to :meth:`~Series.resample` time series to another frequency (e.g.,
+converting secondly data into 5-minutely data).
+
+.. raw:: html
+
+
+
+
+The :meth:`~Series.resample` method is similar to a groupby operation:
+
+- it provides a time-based grouping, by using a string (e.g. ``M``,
+ ``5H``,…) that defines the target frequency
+- it requires an aggregation function such as ``mean``, ``max``,…
+
+.. raw:: html
+
+
+ To user guide
+
+An overview of the aliases used to define time series frequencies is given in the :ref:`offset aliases overview table `.
+
+.. raw:: html
+
+
+
+When defined, the frequency of the time series is provided by the
+``freq`` attribute:
+
+.. ipython:: python
+
+ monthly_max.index.freq
+
+.. raw:: html
+
+
+ -
+
+Make a plot of the daily median :math:`NO_2` value in each of the stations.
+
+.. ipython:: python
+ :okwarning:
+
+ @savefig 09_resample_mean.png
+ no_2.resample("D").mean().plot(style="-o", figsize=(10, 5));
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+More details on the power of time series ``resampling`` is provided in the user gudie section on :ref:`resampling `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+
REMEMBER
+
+- Valid date strings can be converted to datetime objects using
+ ``to_datetime`` function or as part of read functions.
+- Datetime objects in pandas supports calculations, logical operations
+ and convenient date-related properties using the ``dt`` accessor.
+- A ``DatetimeIndex`` contains these date-related properties and
+ supports convenient slicing.
+- ``Resample`` is a powerful method to change the frequency of a time
+ series.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+A full overview on time series is given in the pages on :ref:`time series and date functionality `.
+
+.. raw:: html
+
+
\ No newline at end of file
diff --git a/doc/source/getting_started/intro_tutorials/10_text_data.rst b/doc/source/getting_started/intro_tutorials/10_text_data.rst
new file mode 100644
index 0000000000000..3ff64875d807b
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/10_text_data.rst
@@ -0,0 +1,278 @@
+.. _10min_tut_10_text:
+
+{{ header }}
+
+.. ipython:: python
+
+ import pandas as pd
+
+.. raw:: html
+
+
+
+
+ -
+
+ Titanic data
+
+
+
+
+
+This tutorial uses the titanic data set, stored as CSV. The data
+consists of the following data columns:
+
+- PassengerId: Id of every passenger.
+- Survived: This feature have value 0 and 1. 0 for not survived and 1
+ for survived.
+- Pclass: There are 3 classes: Class 1, Class 2 and Class 3.
+- Name: Name of passenger.
+- Sex: Gender of passenger.
+- Age: Age of passenger.
+- SibSp: Indication that passenger have siblings and spouse.
+- Parch: Whether a passenger is alone or have family.
+- Ticket: Ticket number of passenger.
+- Fare: Indicating the fare.
+- Cabin: The cabin of passenger.
+- Embarked: The embarked category.
+
+.. raw:: html
+
+
+
To raw data
+
+
+
+
+ -
+
+Make all name characters lowercase
+
+.. ipython:: python
+
+ titanic["Name"].str.lower()
+
+To make each of the strings in the ``Name`` column lowercase, select the ``Name`` column
+(see :ref:`tutorial on selection of data <10min_tut_03_subset>`), add the ``str`` accessor and
+apply the ``lower`` method. As such, each of the strings is converted element wise.
+
+.. raw:: html
+
+
+
+
+Similar to datetime objects in the :ref:`time series tutorial <10min_tut_09_timeseries>`
+having a ``dt`` accessor, a number of
+specialized string methods are available when using the ``str``
+accessor. These methods have in general matching names with the
+equivalent built-in string methods for single elements, but are applied
+element-wise (remember :ref:`element wise calculations <10min_tut_05_columns>`?)
+on each of the values of the columns.
+
+.. raw:: html
+
+
+ -
+
+Create a new column ``Surname`` that contains the surname of the Passengers by extracting the part before the comma.
+
+.. ipython:: python
+
+ titanic["Name"].str.split(",")
+
+Using the :meth:`Series.str.split` method, each of the values is returned as a list of
+2 elements. The first element is the part before the comma and the
+second element the part after the comma.
+
+.. ipython:: python
+
+ titanic["Surname"] = titanic["Name"].str.split(",").str.get(0)
+ titanic["Surname"]
+
+As we are only interested in the first part representing the surname
+(element 0), we can again use the ``str`` accessor and apply :meth:`Series.str.get` to
+extract the relevant part. Indeed, these string functions can be
+concatenated to combine multiple functions at once!
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+More information on extracting parts of strings is available in the user guide section on :ref:`splitting and replacing strings `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ -
+
+Extract the passenger data about the Countess on board of the Titanic.
+
+.. ipython:: python
+
+ titanic["Name"].str.contains("Countess")
+
+.. ipython:: python
+
+ titanic[titanic["Name"].str.contains("Countess")]
+
+(*Interested in her story? See*\ `Wikipedia `__\ *!*)
+
+The string method :meth:`Series.str.contains` checks for each of the values in the
+column ``Name`` if the string contains the word ``Countess`` and returns
+for each of the values ``True`` (``Countess`` is part of the name) of
+``False`` (``Countess`` is notpart of the name). This output can be used
+to subselect the data using conditional (boolean) indexing introduced in
+the :ref:`subsetting of data tutorial <10min_tut_03_subset>`. As there was
+only 1 Countess on the Titanic, we get one row as a result.
+
+.. raw:: html
+
+
+
+
+.. note::
+ More powerful extractions on strings is supported, as the
+ :meth:`Series.str.contains` and :meth:`Series.str.extract` methods accepts `regular
+ expressions `__, but out of
+ scope of this tutorial.
+
+.. raw:: html
+
+
+ To user guide
+
+More information on extracting parts of strings is available in the user guide section on :ref:`string matching and extracting `.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ -
+
+Which passenger of the titanic has the longest name?
+
+.. ipython:: python
+
+ titanic["Name"].str.len()
+
+To get the longest name we first have to get the lenghts of each of the
+names in the ``Name`` column. By using pandas string methods, the
+:meth:`Series.str.len` function is applied to each of the names individually
+(element-wise).
+
+.. ipython:: python
+
+ titanic["Name"].str.len().idxmax()
+
+Next, we need to get the corresponding location, preferably the index
+label, in the table for which the name length is the largest. The
+:meth:`~Series.idxmax`` method does exactly that. It is not a string method and is
+applied to integers, so no ``str`` is used.
+
+.. ipython:: python
+
+ titanic.loc[titanic["Name"].str.len().idxmax(), "Name"]
+
+Based on the index name of the row (``307``) and the column (``Name``),
+we can do a selection using the ``loc`` operator, introduced in the
+`tutorial on subsetting <3_subset_data.ipynb>`__.
+
+.. raw:: html
+
+
+
+
+.. raw:: html
+
+
+ -
+
+In the ‘Sex’ columns, replace values of ‘male’ by ‘M’ and all ‘female’ values by ‘F’
+
+.. ipython:: python
+
+ titanic["Sex_short"] = titanic["Sex"].replace({"male": "M",
+ "female": "F"})
+ titanic["Sex_short"]
+
+Whereas :meth:`~Series.replace` is not a string method, it provides a convenient way
+to use mappings or vocabularies to translate certain values. It requires
+a ``dictionary`` to define the mapping ``{from : to}``.
+
+.. raw:: html
+
+
+
+
+.. warning::
+ There is also a :meth:`~Series.str.replace` methods available to replace a
+ specific set of characters. However, when having a mapping of multiple
+ values, this would become:
+
+ ::
+
+ titanic["Sex_short"] = titanic["Sex"].str.replace("female", "F")
+ titanic["Sex_short"] = titanic["Sex_short"].str.replace("male", "M")
+
+ This would become cumbersome and easily lead to mistakes. Just think (or
+ try out yourself) what would happen if those two statements are applied
+ in the opposite order…
+
+.. raw:: html
+
+
+
REMEMBER
+
+- String methods are available using the ``str`` accessor.
+- String methods work element wise and can be used for conditional
+ indexing.
+- The ``replace`` method is a convenient method to convert values
+ according to a given dictionary.
+
+.. raw:: html
+
+
+
+.. raw:: html
+
+
+ To user guide
+
+A full overview is provided in the user guide pages on :ref:`working with text data `.
+
+.. raw:: html
+
+
diff --git a/doc/source/getting_started/intro_tutorials/index.rst b/doc/source/getting_started/intro_tutorials/index.rst
new file mode 100644
index 0000000000000..28e7610866461
--- /dev/null
+++ b/doc/source/getting_started/intro_tutorials/index.rst
@@ -0,0 +1,22 @@
+{{ header }}
+
+.. _10times1minute:
+
+=========================
+Getting started tutorials
+=========================
+
+.. toctree::
+ :maxdepth: 1
+
+ 01_table_oriented
+ 02_read_write
+ 03_subset_data
+ 04_plotting
+ 05_add_columns
+ 06_calculate_statistics
+ 07_reshape_table_layout
+ 08_combine_dataframes
+ 09_timeseries
+ 10_text_data
+
diff --git a/doc/source/index.rst.template b/doc/source/index.rst.template
index 820a9d6285e0e..5428239ed2e27 100644
--- a/doc/source/index.rst.template
+++ b/doc/source/index.rst.template
@@ -104,6 +104,7 @@ programming language.
{% if single_doc and single_doc.endswith('.rst') -%}
.. toctree::
:maxdepth: 3
+ :titlesonly:
{{ single_doc[:-4] }}
{% elif single_doc %}
@@ -115,6 +116,7 @@ programming language.
.. toctree::
:maxdepth: 3
:hidden:
+ :titlesonly:
{% endif %}
{% if not single_doc %}
What's New in 1.0.1
diff --git a/doc/source/user_guide/reshaping.rst b/doc/source/user_guide/reshaping.rst
index b28354cd8b5f2..bbec9a770477d 100644
--- a/doc/source/user_guide/reshaping.rst
+++ b/doc/source/user_guide/reshaping.rst
@@ -6,6 +6,8 @@
Reshaping and pivot tables
**************************
+.. _reshaping.reshaping:
+
Reshaping by pivoting DataFrame objects
---------------------------------------
@@ -314,6 +316,8 @@ user-friendly.
dft
pd.wide_to_long(dft, ["A", "B"], i="id", j="year")
+.. _reshaping.combine_with_groupby:
+
Combining with stats and GroupBy
--------------------------------
diff --git a/doc/source/user_guide/text.rst b/doc/source/user_guide/text.rst
index 88c86ac212f11..2e4d0fecaf5cf 100644
--- a/doc/source/user_guide/text.rst
+++ b/doc/source/user_guide/text.rst
@@ -189,12 +189,11 @@ and replacing any remaining whitespaces with underscores:
Generally speaking, the ``.str`` accessor is intended to work only on strings. With very few
exceptions, other uses are not supported, and may be disabled at a later point.
+.. _text.split:
Splitting and replacing strings
-------------------------------
-.. _text.split:
-
Methods like ``split`` return a Series of lists:
.. ipython:: python
+ 
+ 
+ 
+