code/Introduction_to_Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro into Strings \n",
    "\n",
    "**Authorship**<br />\n",
    "Original Author: Nicholas Davis<br />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with text data <br />\n",
    "\n",
    "Enterprise analytics workflows commonly require processing large-scale text data. To address this need, the RAPIDS CUDA DataFrame library (cuDF) and RAPIDS CUDA Machine Learning library (cuML) now include string processing capabilities. cuDF has a fully-featured string and regular expression processing engine. With a pandas-like API, cuDF string analytics can provide data scientists with up to 90x performance improvement with minimal changes to their code.<br />\n",
    "\n",
    "This notebook serves as an intro to string capabilities with cuDF. Each string functionality will have a pandas example and it's cuDF equivalent.<br />\n",
    "\n",
    "For any additional information please reference:<br />\n",
    "[cuDF Documentation](https://docs.rapids.ai/api/cudf/stable/api.html#strings)<br /><br />\n",
    "[GPU-Accelerated String Processing with RAPIDS Video](https://www.nvidia.com/en-us/on-demand/session/gtcfall20-a21131/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Before we begin, let's check out our hardware setup by running the nvidia-smi command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon Mar 11 16:25:31 2024       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 525.147.05   Driver Version: 525.147.05   CUDA Version: 12.0     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  Quadro GV100        Off  | 00000000:15:00.0 Off |                  Off |\n",
      "| 29%   40C    P2    26W / 250W |  12750MiB / 32768MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   1  Quadro GV100        Off  | 00000000:2D:00.0 Off |                  Off |\n",
      "| 33%   46C    P2    29W / 250W |   3497MiB / 32768MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two ways to store text data in pandas and cudf:\n",
    "\n",
    "1. object -dtype NumPy array.\n",
    "\n",
    "1. StringDtype extension type.\n",
    "\n",
    "We recommend using StringDtype to store text data.\n",
    "\n",
    "Prior to pandas 1.0, object dtype was the only option. This was unfortunate for many reasons:\n",
    "\n",
    "1. You can accidentally store a mixture of strings and non-strings in an object dtype array. It’s better to have a dedicated dtype.\n",
    "\n",
    "1. object dtype breaks dtype-specific operations like `DataFrame.select_dtypes()`. There isn’t a clear way to select just text while excluding non-text but still object-dtype columns.\n",
    "\n",
    "1. When reading code, the contents of an object dtype array is less clear than 'string'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Currently, the performance of object dtype arrays of strings and arrays.StringArray are about the same. We expect future enhancements to significantly increase the performance and lower the memory overhead of StringArray.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pandas Version: 1.5.3\n",
      "CuDF Version: 24.02.02\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd; print('Pandas Version:', pd.__version__)\n",
    "import numpy as np\n",
    "import cupy as cp\n",
    "import cudf; print('CuDF Version:', cudf.__version__)\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "For backwards-compatibility, object dtype remains the default type we infer a list of strings to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a\n",
       "1    b\n",
       "2    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pandas\n",
    "\n",
    "pd.Series([\"a\", \"b\", \"c\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a\n",
       "1    b\n",
       "2    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cuDF\n",
    "\n",
    "cudf.Series([\"a\", \"b\", \"c\"])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "To explicitly request string dtype, specify the dtype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a\n",
       "1    b\n",
       "2    c\n",
       "dtype: string"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([\"a\", \"b\", \"c\"], dtype=\"string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a\n",
       "1    b\n",
       "2    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudf.Series([\"a\", \"b\", \"c\"], dtype=\"str\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Or astype after the Series or DataFrame is created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0    a\n",
      "1    b\n",
      "2    c\n",
      "dtype: string\n",
      "\n",
      "# of 'n': \n",
      "0    0\n",
      "1    0\n",
      "2    0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "pandasSeries = pd.Series([\"a\", \"b\", \"c\"])\n",
    "print('Original: ')\n",
    "print(pandasSeries.astype(\"string\"))\n",
    "\n",
    "print(\"\\n# of 'n': \")\n",
    "print(pandasSeries.str.count('n'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0    a\n",
      "1    b\n",
      "2    c\n",
      "dtype: object\n",
      "\n",
      "# of 'n': \n",
      "0    0\n",
      "1    0\n",
      "2    0\n",
      "dtype: int32\n"
     ]
    }
   ],
   "source": [
    "cudfSeries = cudf.Series([\"a\", \"b\", \"c\"])\n",
    "print('Original: ')\n",
    "print(cudfSeries.astype(\"string\"))\n",
    "\n",
    "print(\"\\n# of 'n': \")\n",
    "print(cudfSeries.str.count('n'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "You can also use StringDtype/\"string\" as the dtype on non-string data and it will be converted to string dtype:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0       a\n",
      "1       2\n",
      "2    <NA>\n",
      "dtype: string\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries = pd.Series([\"a\", 2, np.nan], dtype=\"string\")\n",
    "print(pandasSeries)\n",
    "type(pandasSeries[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0       a\n",
      "1       2\n",
      "2    <NA>\n",
      "dtype: object\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries = cudf.Series([\"a\", 2, np.nan], dtype=\"str\")\n",
    "print(cudfSeries)\n",
    "type(cudfSeries[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "or convert from existing pandas data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0       1\n",
      "1       2\n",
      "2    <NA>\n",
      "dtype: string\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries = pd.Series([1, 2, np.nan], dtype=\"Int64\")\n",
    "\n",
    "pandasSeries2 = pandasSeries.astype(\"string\")\n",
    "print(pandasSeries2)\n",
    "type(pandasSeries2[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0       1\n",
      "1       2\n",
      "2    <NA>\n",
      "dtype: object\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries1 = cudf.Series([1, 2, np.nan], dtype=\"int64\")\n",
    "\n",
    "cudfSeries2 = cudfSeries1.astype(\"string\")\n",
    "print(cudfSeries2)\n",
    "type(cudfSeries2[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Behavior differences\n",
    "\n",
    "These are places where the behavior of StringDtype objects differ from object dtype."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `StringDtype`, string accessor methods that return numeric output will always return a nullable integer dtype, rather than either int or float dtype, depending on the presence of `NA` values. Methods returning boolean output will return a nullable boolean dtype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0       a\n",
      "1    <NA>\n",
      "2       b\n",
      "dtype: string\n",
      "# of 'a': \n",
      "0       1\n",
      "1    <NA>\n",
      "2       0\n",
      "dtype: Int64\n",
      "\n",
      "# of 'a' after dropping n/a: \n",
      "0    1\n",
      "2    0\n",
      "dtype: Int64\n",
      "\n",
      "Check if numeric: \n",
      "0    False\n",
      "1     <NA>\n",
      "2    False\n",
      "dtype: boolean\n"
     ]
    }
   ],
   "source": [
    "pandasSeries = pd.Series([\"a\", None, \"b\"], dtype=\"string\")\n",
    "print('Original: ')\n",
    "print(pandasSeries)\n",
    "print(\"# of 'a': \")\n",
    "print(pandasSeries.str.count(\"a\"))\n",
    "print(\"\\n# of 'a' after dropping n/a: \")\n",
    "print(pandasSeries.dropna().str.count(\"a\"))\n",
    "print(\"\\nCheck if numeric: \")\n",
    "print(pandasSeries.str.isnumeric())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0       a\n",
      "1    <NA>\n",
      "2       b\n",
      "dtype: object\n",
      "# of 'a': \n",
      "0       1\n",
      "1    <NA>\n",
      "2       0\n",
      "dtype: int32\n",
      "\n",
      "# of 'a' after dropping n/a: \n",
      "0    1\n",
      "2    0\n",
      "dtype: int32\n",
      "\n",
      "Check if numeric: \n",
      "0    False\n",
      "1     <NA>\n",
      "2    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "cudfSeries = cudf.Series([\"a\", None, \"b\"], dtype=\"str\")\n",
    "print('Original: ')\n",
    "print(cudfSeries)\n",
    "print(\"# of 'a': \")\n",
    "print(cudfSeries.str.count(\"a\"))\n",
    "print(\"\\n# of 'a' after dropping n/a: \")\n",
    "print(cudfSeries.dropna().str.count(\"a\"))\n",
    "print(\"\\nCheck if numeric: \")\n",
    "print(cudfSeries.str.isnumeric())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Both outputs are Int64 dtype. Compare that with object-dtype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# of 'a': \n",
      "0    1.0\n",
      "1    NaN\n",
      "2    0.0\n",
      "dtype: float64\n",
      "\n",
      "# of 'a' after dropping n/a: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "2    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries2 = pd.Series([\"a\", None, \"b\"], dtype=\"object\")\n",
    "print(\"# of 'a': \")\n",
    "print(pandasSeries2.str.count(\"a\"))\n",
    "print(\"\\n# of 'a' after dropping n/a: \")\n",
    "pandasSeries2.dropna().str.count(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# of 'a': \n",
      "0       1\n",
      "1    <NA>\n",
      "2       0\n",
      "dtype: int32\n",
      "\n",
      "# of 'a' after dropping n/a: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "2    0\n",
       "dtype: int32"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries2 = cudf.Series([\"a\", None, \"b\"], dtype=\"object\")\n",
    "print(\"# of 'a': \")\n",
    "print(cudfSeries2.str.count(\"a\"))\n",
    "print(\"\\n# of 'a' after dropping n/a: \")\n",
    "cudfSeries2.dropna().str.count(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "When NA values are present, the output dtype is float64. Similarly for methods returning boolean values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check if digit: \n",
      "0    False\n",
      "1     <NA>\n",
      "2    False\n",
      "dtype: boolean\n",
      "\n",
      "Match against 'a': \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1     <NA>\n",
       "2    False\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Check if digit: \")\n",
    "print(pandasSeries.str.isdigit())\n",
    "print(\"\\nMatch against 'a': \")\n",
    "pandasSeries.str.match(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check if digit: \n",
      "0    False\n",
      "1     <NA>\n",
      "2    False\n",
      "dtype: bool\n",
      "\n",
      "Match against 'a': \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1     <NA>\n",
       "2    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Check if digit: \")\n",
    "print(cudfSeries.str.isdigit())\n",
    "print(\"\\nMatch against 'a': \")\n",
    "cudfSeries.str.match(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br />\n",
    "\n",
    "Some string methods, like `Series.str.decode()` are not available on StringArray because StringArray only holds strings, not bytes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In comparison operations, `arrays.StringArray` and Series backed by a `StringArray` will return an object with `BooleanDtype`, rather than a bool dtype object. Missing values in a `StringArray` will propagate in comparison operations, rather than always comparing unequal like `numpy.nan`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything else that follows in the rest of this document applies equally to string and object dtype."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## String methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series and Index are equipped with a set of string processing methods that make it easy to operate on each element of the array. Perhaps most importantly, these methods exclude missing/NA values automatically. These are accessed via the str attribute and generally have names matching the equivalent (scalar) built-in string methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3    Aaba\n",
      "4    Baca\n",
      "5    <NA>\n",
      "6    CABA\n",
      "7     dog\n",
      "8     cat\n",
      "dtype: string\n",
      "\n",
      "Lowered: \n",
      "0       a\n",
      "1       b\n",
      "2       c\n",
      "3    aaba\n",
      "4    baca\n",
      "5    <NA>\n",
      "6    caba\n",
      "7     dog\n",
      "8     cat\n",
      "dtype: string\n",
      "\n",
      "Check if Lowered: \n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "4    False\n",
      "5     <NA>\n",
      "6    False\n",
      "7     True\n",
      "8     True\n",
      "dtype: boolean\n",
      "\n",
      "Uppercase: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3    AABA\n",
      "4    BACA\n",
      "5    <NA>\n",
      "6    CABA\n",
      "7     DOG\n",
      "8     CAT\n",
      "dtype: string\n",
      "\n",
      "Check if Uppercase: \n",
      "0     True\n",
      "1     True\n",
      "2     True\n",
      "3    False\n",
      "4    False\n",
      "5     <NA>\n",
      "6     True\n",
      "7    False\n",
      "8    False\n",
      "dtype: boolean\n",
      "\n",
      "Determine Length: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0       1\n",
       "1       1\n",
       "2       1\n",
       "3       4\n",
       "4       4\n",
       "5    <NA>\n",
       "6       4\n",
       "7       3\n",
       "8       3\n",
       "dtype: Int64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries = pd.Series(\n",
    "  ....:     [\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"], dtype=\"string\"\n",
    "  ....: )\n",
    "  ....: \n",
    "print('Original: ')\n",
    "print(pandasSeries)\n",
    "print('\\nLowered: ')\n",
    "print(pandasSeries.str.lower())\n",
    "print('\\nCheck if Lowered: ')\n",
    "print(pandasSeries.str.islower())\n",
    "print('\\nUppercase: ')\n",
    "print(pandasSeries.str.upper())\n",
    "print('\\nCheck if Uppercase: ')\n",
    "print(pandasSeries.str.isupper())\n",
    "print('\\nDetermine Length: ')\n",
    "pandasSeries.str.len()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3    Aaba\n",
      "4    Baca\n",
      "5    <NA>\n",
      "6    CABA\n",
      "7     dog\n",
      "8     cat\n",
      "dtype: object\n",
      "\n",
      "Lowered: \n",
      "0       a\n",
      "1       b\n",
      "2       c\n",
      "3    aaba\n",
      "4    baca\n",
      "5    <NA>\n",
      "6    caba\n",
      "7     dog\n",
      "8     cat\n",
      "dtype: object\n",
      "\n",
      "Check if Lowered: \n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "4    False\n",
      "5     <NA>\n",
      "6    False\n",
      "7     True\n",
      "8     True\n",
      "dtype: bool\n",
      "\n",
      "Uppercase: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3    AABA\n",
      "4    BACA\n",
      "5    <NA>\n",
      "6    CABA\n",
      "7     DOG\n",
      "8     CAT\n",
      "dtype: object\n",
      "\n",
      "Check if Uppercase: \n",
      "0     True\n",
      "1     True\n",
      "2     True\n",
      "3    False\n",
      "4    False\n",
      "5     <NA>\n",
      "6     True\n",
      "7    False\n",
      "8    False\n",
      "dtype: bool\n",
      "\n",
      "Determine Length: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0       1\n",
       "1       1\n",
       "2       1\n",
       "3       4\n",
       "4       4\n",
       "5    <NA>\n",
       "6       4\n",
       "7       3\n",
       "8       3\n",
       "dtype: int32"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries = cudf.Series(\n",
    "  ....:     [\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"], dtype=\"str\"\n",
    "  ....: )\n",
    "  ....: \n",
    "\n",
    "print('Original: ')\n",
    "print(cudfSeries)\n",
    "print('\\nLowered: ')\n",
    "print(cudfSeries.str.lower())\n",
    "print('\\nCheck if Lowered: ')\n",
    "print(cudfSeries.str.islower())\n",
    "print('\\nUppercase: ')\n",
    "print(cudfSeries.str.upper())\n",
    "print('\\nCheck if Uppercase: ')\n",
    "print(cudfSeries.str.isupper())\n",
    "print('\\nDetermine Length: ')\n",
    "cudfSeries.str.len()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Right Strip: \n",
      "Index([' jack', 'jill', ' jesse', 'frank'], dtype='object')\n",
      "\n",
      "Left Strip: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Index(['jack', 'jill ', 'jesse ', 'frank'], dtype='object')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasIdx = pd.Index([\" jack\", \"jill \", \" jesse \", \"frank\"])\n",
    "\n",
    "pandasIdx.str.strip()\n",
    "\n",
    "print('Right Strip: ')\n",
    "print(pandasIdx.str.rstrip())\n",
    "\n",
    "print('\\nLeft Strip: ')\n",
    "pandasIdx.str.lstrip()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Right Strip: \n",
      "StringIndex([' jack' 'jill' ' jesse' 'frank'], dtype='object')\n",
      "\n",
      "Left Strip: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "StringIndex(['jack' 'jill ' 'jesse ' 'frank'], dtype='object')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfIdx = cudf.Index([\" jack\", \"jill \", \" jesse \", \"frank\"])\n",
    "\n",
    "cudfIdx.str.strip()\n",
    "\n",
    "print('Right Strip: ')\n",
    "print(cudfIdx.str.rstrip())\n",
    "\n",
    "print('\\nLeft Strip: ')\n",
    "cudfIdx.str.lstrip()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The string methods on Index are especially useful for cleaning up or transforming DataFrame columns. For instance, you may have columns with leading or trailing whitespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Column A</th>\n",
       "      <th>Column B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.766351</td>\n",
       "      <td>-0.006574</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.034232</td>\n",
       "      <td>-1.638306</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.836389</td>\n",
       "      <td>-1.506215</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Column A    Column B \n",
       "0    1.766351   -0.006574\n",
       "1   -0.034232   -1.638306\n",
       "2   -0.836389   -1.506215"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasDataFrame = pd.DataFrame(np.random.randn(3, 2), columns=[\" Column A \", \" Column B \"], index=range(3))\n",
    "   \n",
    "pandasDataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Column A</th>\n",
       "      <th>Column B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.234977</td>\n",
       "      <td>-0.617927</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.824023</td>\n",
       "      <td>0.061936</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.066182</td>\n",
       "      <td>0.006777</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Column A    Column B \n",
       "0    0.234977   -0.617927\n",
       "1   -1.824023    0.061936\n",
       "2   -0.066182    0.006777"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfDataFrame = cudf.DataFrame(np.random.randn(3, 2), columns=[\" Column A \", \" Column B \"], index=range(3))\n",
    "   \n",
    "cudfDataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Since df.columns is an Index object, we can use the .str accessor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stripped: \n",
      "Index(['Column A', 'Column B'], dtype='object')\n",
      "\n",
      "Lowered: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Index([' column a ', ' column b '], dtype='object')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Stripped: \")\n",
    "print(pandasDataFrame.columns.str.strip())\n",
    "print(\"\\nLowered: \")\n",
    "pandasDataFrame.columns.str.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stripped: \n",
      "Index(['Column A', 'Column B'], dtype='object')\n",
      "\n",
      "Lowered: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Index([' column a ', ' column b '], dtype='object')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Stripped: \")\n",
    "print(cudfDataFrame.columns.str.strip())\n",
    "print(\"\\nLowered: \")\n",
    "cudfDataFrame.columns.str.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "These string methods can then be used to clean up the columns as needed. Here we are removing leading and trailing whitespaces, lower casing all names, and replacing any remaining whitespaces with underscores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>column_a</th>\n",
       "      <th>column_b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.766351</td>\n",
       "      <td>-0.006574</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.034232</td>\n",
       "      <td>-1.638306</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.836389</td>\n",
       "      <td>-1.506215</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   column_a  column_b\n",
       "0  1.766351 -0.006574\n",
       "1 -0.034232 -1.638306\n",
       "2 -0.836389 -1.506215"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasDataFrame.columns = pandasDataFrame.columns.str.strip().str.lower().str.replace(\" \", \"_\")\n",
    "pandasDataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>column_a</th>\n",
       "      <th>column_b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.234977</td>\n",
       "      <td>-0.617927</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.824023</td>\n",
       "      <td>0.061936</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.066182</td>\n",
       "      <td>0.006777</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   column_a  column_b\n",
       "0  0.234977 -0.617927\n",
       "1 -1.824023  0.061936\n",
       "2 -0.066182  0.006777"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfDataFrame.columns = cudfDataFrame.columns.str.strip().str.lower().str.replace(\" \", \"_\")\n",
    "cudfDataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting and replacing strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods like split return a Series of lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [a, b, c]\n",
       "1    [c, d, e]\n",
       "2         <NA>\n",
       "3    [f, g, h]\n",
       "dtype: object"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries3 = pd.Series([\"a_b_c\", \"c_d_e\", np.nan, \"f_g_h\"], dtype=\"string\")\n",
    "pandasSeries3.str.split(\"_\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [a, b, c]\n",
       "1    [c, d, e]\n",
       "2         None\n",
       "3    [f, g, h]\n",
       "dtype: list"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries3 = cudf.Series([\"a_b_c\", \"c_d_e\", np.nan, \"f_g_h\"], dtype=\"str\")\n",
    "cudfSeries3.str.split(\"_\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "It is easy to expand this to return a DataFrame using expand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>b</td>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c</td>\n",
       "      <td>d</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f</td>\n",
       "      <td>g</td>\n",
       "      <td>h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1     2\n",
       "0     a     b     c\n",
       "1     c     d     e\n",
       "2  <NA>  <NA>  <NA>\n",
       "3     f     g     h"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries3.str.split(\"_\", expand=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>b</td>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c</td>\n",
       "      <td>d</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f</td>\n",
       "      <td>g</td>\n",
       "      <td>h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1     2\n",
       "0     a     b     c\n",
       "1     c     d     e\n",
       "2  <NA>  <NA>  <NA>\n",
       "3     f     g     h"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries3.str.split(\"_\", expand=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "When original Series has StringDtype, the output columns will all be StringDtype as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to limit the number of splits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>b_c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c</td>\n",
       "      <td>d_e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f</td>\n",
       "      <td>g_h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1\n",
       "0     a   b_c\n",
       "1     c   d_e\n",
       "2  <NA>  <NA>\n",
       "3     f   g_h"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries3.str.split(\"_\", expand=True, n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>b_c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c</td>\n",
       "      <td>d_e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f</td>\n",
       "      <td>g_h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1\n",
       "0     a   b_c\n",
       "1     c   d_e\n",
       "2  <NA>  <NA>\n",
       "3     f   g_h"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries3.str.split(\"_\", expand=True, n=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "rsplit is similar to split except it works in the reverse direction, i.e., from the end of the string to the beginning of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a_b</td>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c_d</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f_g</td>\n",
       "      <td>h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1\n",
       "0   a_b     c\n",
       "1   c_d     e\n",
       "2  <NA>  <NA>\n",
       "3   f_g     h"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries3.str.rsplit(\"_\", expand=True, n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a_b</td>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>c_d</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f_g</td>\n",
       "      <td>h</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1\n",
       "0   a_b     c\n",
       "1   c_d     e\n",
       "2  <NA>  <NA>\n",
       "3   f_g     h"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries3.str.rsplit(\"_\", expand=True, n=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The replace method\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "replace optionally uses regular expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3    Aaba\n",
      "4    Baca\n",
      "5        \n",
      "6    <NA>\n",
      "7    CABA\n",
      "8     dog\n",
      "9     cat\n",
      "dtype: string\n",
      "\n",
      "Replaced: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0           A\n",
       "1           B\n",
       "2           C\n",
       "3    XX-XX ba\n",
       "4    XX-XX ca\n",
       "5            \n",
       "6        <NA>\n",
       "7        CABA\n",
       "8      XX-XX \n",
       "9     XX-XX t\n",
       "dtype: string"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries4 = pd.Series(\n",
    "   ....:     [\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", \"\", np.nan, \"CABA\", \"dog\", \"cat\"],\n",
    "   ....:     dtype=\"string\",\n",
    "   ....: )\n",
    "   ....: \n",
    "print('Original: ')\n",
    "print(pandasSeries4) \n",
    "print('\\nReplaced: ')\n",
    "pandasSeries4.str.replace(\"^.a|dog\", \"XX-XX \", regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3    Aaba\n",
      "4    Baca\n",
      "5        \n",
      "6    <NA>\n",
      "7    CABA\n",
      "8     dog\n",
      "9     cat\n",
      "dtype: object\n",
      "\n",
      "Replaced: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0           A\n",
       "1           B\n",
       "2           C\n",
       "3    XX-XX ba\n",
       "4    XX-XX ca\n",
       "5            \n",
       "6        <NA>\n",
       "7        CABA\n",
       "8      XX-XX \n",
       "9     XX-XX t\n",
       "dtype: object"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries4 = cudf.Series(\n",
    "   ....:     [\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", \"\", np.nan, \"CABA\", \"dog\", \"cat\"],\n",
    "   ....:     dtype=\"str\",\n",
    "   ....: )\n",
    "   ....: \n",
    "print('Original: ')\n",
    "print(cudfSeries4) \n",
    "print('\\nReplaced: ')\n",
    "cudfSeries4.str.replace(\"^.a|dog\", \"XX-XX \",  regex=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "If you want literal replacement of a string (equivalent to str.replace()), you can set the optional regex parameter to False, rather than escaping each character. In this case both pat and repl must be strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0         12\n",
      "1        -10\n",
      "2    $10,000\n",
      "dtype: string\n",
      "\n",
      "Are these equivalent? \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0         12\n",
       "1        -10\n",
       "2    $10,000\n",
       "dtype: string"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasdollars = pd.Series([\"12\", \"-$10\", \"$10,000\"], dtype=\"string\")\n",
    "\n",
    "# These lines are equivalent\n",
    "print(pandasdollars.str.replace(r\"-\\$\", \"-\", regex=True))\n",
    "print(\"\\nAre these equivalent? \\n\")\n",
    "pandasdollars.str.replace(\"-$\", \"-\", regex=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0         12\n",
      "1        -10\n",
      "2    $10,000\n",
      "dtype: object\n",
      "\n",
      "Are these equivalent? \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0         12\n",
       "1        -10\n",
       "2    $10,000\n",
       "dtype: object"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfDollars = cudf.Series([\"12\", \"-$10\", \"$10,000\"], dtype=\"str\")\n",
    "\n",
    "# These lines are equivalent\n",
    "print(cudfDollars.str.replace(r\"-\\$\", \"-\", regex=True))\n",
    "print(\"\\nAre these equivalent? \\n\")\n",
    "cudfDollars.str.replace(\"-$\", \"-\", regex=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several ways to concatenate a Series or Index, either with itself or others, all based on cat(), resp. Index.str.cat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenating a single Series into a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The content of a Series (or Index) can be concatenated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a,b,c,d'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries = pd.Series([\"a\", \"b\", \"c\", \"d\"], dtype=\"string\")\n",
    "\n",
    "pandasSeries.str.cat(sep=\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a,b,c,d'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries = cudf.Series([\"a\", \"b\", \"c\", \"d\"], dtype=\"str\")\n",
    "\n",
    "cudfSeries.str.cat(sep=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "If not specified, the keyword sep for the separator defaults to the empty string, sep='':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries.str.cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries.str.cat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "By default, missing values are ignored. Using na_rep, they can be given a representation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seperated by ,: \n",
      "a,b,d\n",
      "\n",
      "Seperated by , & -: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'a,b,-,d'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeriesB = pd.Series([\"a\", \"b\", np.nan, \"d\"], dtype=\"string\")\n",
    "print('Seperated by ,: ')\n",
    "print(pandasSeriesB.str.cat(sep=\",\"))\n",
    "print('\\nSeperated by , & -: ')\n",
    "pandasSeriesB.str.cat(sep=\",\", na_rep=\"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seperated by ,: \n",
      "a,b,d\n",
      "\n",
      "Seperated by , & -: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'a,b,-,d'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeriesB = cudf.Series([\"a\", \"b\", np.nan, \"d\"], dtype=\"str\")\n",
    "print('Seperated by ,: ')\n",
    "print(cudfSeriesB.str.cat(sep=\",\"))\n",
    "print('\\nSeperated by , & -: ')\n",
    "cudfSeriesB.str.cat(sep=\",\", na_rep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenating a Series and something list-like into a Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first argument to cat() can be a list-like object, provided that it matches the length of the calling Series (or Index)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    aA\n",
       "1    bB\n",
       "2    cC\n",
       "3    dD\n",
       "dtype: string"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries.str.cat([\"A\", \"B\", \"C\", \"D\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    aA\n",
       "1    bB\n",
       "2    cC\n",
       "3    dD\n",
       "dtype: object"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries.str.cat([\"A\", \"B\", \"C\", \"D\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Missing values on either side will result in missing values in the result as well, unless na_rep is specified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0      aa\n",
      "1      bb\n",
      "2    <NA>\n",
      "3      dd\n",
      "dtype: string\n",
      "\n",
      "na_rep is specified\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    aa\n",
       "1    bb\n",
       "2    c-\n",
       "3    dd\n",
       "dtype: string"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Original: ')\n",
    "print(pandasSeries.str.cat(pandasSeriesB))\n",
    "print('\\nna_rep is specified')\n",
    "pandasSeries.str.cat(pandasSeriesB, na_rep=\"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0      aa\n",
      "1      bb\n",
      "2    <NA>\n",
      "3      dd\n",
      "dtype: object\n",
      "\n",
      "na_rep is specified\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    aa\n",
       "1    bb\n",
       "2    c-\n",
       "3    dd\n",
       "dtype: object"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Original: ')\n",
    "print(cudfSeries.str.cat(cudfSeriesB))\n",
    "print('\\nna_rep is specified')\n",
    "cudfSeries.str.cat(cudfSeriesB, na_rep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Concatenating a Series and something array-like into a Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parameter others can also be two-dimensional. In this case, the number or rows must match the lengths of the calling Series (or Index)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0    a\n",
      "1    b\n",
      "2    c\n",
      "3    d\n",
      "dtype: string\n",
      "\n",
      "Concatenating a Series and something array-like\n",
      "      0  1\n",
      "0     a  a\n",
      "1     b  b\n",
      "2  <NA>  c\n",
      "3     d  d\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    aaa\n",
       "1    bbb\n",
       "2    c-c\n",
       "3    ddd\n",
       "dtype: string"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasArray = pd.concat([pandasSeriesB, pandasSeries], axis=1)\n",
    "print('Original: ')\n",
    "print(pandasSeries)\n",
    "print('\\nConcatenating a Series and something array-like')\n",
    "print(pandasArray)\n",
    "pandasSeries.str.cat(pandasArray, na_rep=\"-\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: \n",
      "0    a\n",
      "1    b\n",
      "2    c\n",
      "3    d\n",
      "dtype: object\n",
      "\n",
      "Concatenating a Series and something array-like\n",
      "      0  1\n",
      "0     a  a\n",
      "1     b  b\n",
      "2  <NA>  c\n",
      "3     d  d\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    aaa\n",
       "1    bbb\n",
       "2    c-c\n",
       "3    ddd\n",
       "Name: 1, dtype: object"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfArray = cudf.concat([cudfSeriesB, cudfSeries], axis=1)\n",
    "print('Original: ')\n",
    "print(cudfSeries)\n",
    "print('\\nConcatenating a Series and something array-like')\n",
    "print(cudfArray)\n",
    "cudfArray[1].str.cat(cudfArray[0], na_rep=\"-\").str.cat(cudfSeries, na_rep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Indexing with .str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `[]` notation to directly index by position locations. If you index past the end of the string, the result will be a NaN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indexed at position 0: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3       A\n",
      "4       B\n",
      "5    <NA>\n",
      "6       C\n",
      "7       d\n",
      "8       c\n",
      "dtype: string\n",
      "\n",
      "Indexed at position 1: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0    <NA>\n",
       "1    <NA>\n",
       "2    <NA>\n",
       "3       a\n",
       "4       a\n",
       "5    <NA>\n",
       "6       A\n",
       "7       o\n",
       "8       a\n",
       "dtype: string"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pandasSeries = pd.Series([\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"], dtype=\"string\")\n",
    "   \n",
    "print('Indexed at position 0: ')\n",
    "print(pandasSeries.str[0])\n",
    "print('\\nIndexed at position 1: ')\n",
    "pandasSeries.str[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indexed at position 0: \n",
      "0       A\n",
      "1       B\n",
      "2       C\n",
      "3       A\n",
      "4       B\n",
      "5    <NA>\n",
      "6       C\n",
      "7       d\n",
      "8       c\n",
      "dtype: object\n",
      "\n",
      "Indexed at position 1: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0        \n",
       "1        \n",
       "2        \n",
       "3       a\n",
       "4       a\n",
       "5    <NA>\n",
       "6       A\n",
       "7       o\n",
       "8       a\n",
       "dtype: object"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudfSeries = cudf.Series([\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"], dtype=\"str\")\n",
    "   \n",
    "print('Indexed at position 0: ')\n",
    "print(cudfSeries.str[0])\n",
    "print('\\nIndexed at position 1: ')\n",
    "cudfSeries.str[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Extracting substrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract first match in each subject (`extract`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0     1\n",
      "0     a     1\n",
      "1     b     2\n",
      "2  <NA>  <NA>\n"
     ]
    }
   ],
   "source": [
    "pdSeries = pd.Series([\"a1\", \"b2\", \"c3\"],dtype=\"string\",).str.extract(r\"([ab])(\\d)\", )\n",
    "print(pdSeries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0     1\n",
      "0     a     1\n",
      "1     b     2\n",
      "2  <NA>  <NA>\n"
     ]
    }
   ],
   "source": [
    "cudfSeries = cudf.Series(['a1', 'b2', 'c3']).str.extract(r'([ab])(\\d)')\n",
    "print(cudfSeries)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Extracting a regular expression with one group returns a DataFrame with one column if `expand=True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0\n",
       "0     1\n",
       "1     2\n",
       "2  <NA>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([\"a1\", \"b2\", \"c3\"], dtype=\"string\").str.extract(r\"[ab](\\d)\", expand=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>&lt;NA&gt;</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0\n",
       "0     1\n",
       "1     2\n",
       "2  <NA>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudf.Series([\"a1\", \"b2\", \"c3\"], dtype=\"str\").str.extract(r\"[ab](\\d)\", expand=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It returns a Series if `expand=False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       1\n",
       "1       2\n",
       "2    <NA>\n",
       "dtype: string"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([\"a1\", \"b2\", \"c3\"], dtype=\"string\").str.extract(r\"[ab](\\d)\", expand=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       1\n",
       "1       2\n",
       "2    <NA>\n",
       "dtype: object"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudf.Series([\"a1\", \"b2\", \"c3\"], dtype=\"str\").str.extract(r\"[ab](\\d)\", expand=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "When each subject string in the Series has exactly one match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    a3\n",
      "1    b3\n",
      "2    c2\n",
      "dtype: string\n"
     ]
    }
   ],
   "source": [
    "pandasSeries = pd.Series([\"a3\", \"b3\", \"c2\"], dtype=\"string\")\n",
    "print(pandasSeries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    a3\n",
      "1    b3\n",
      "2    c2\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "cudfSeries = cudf.Series([\"a3\", \"b3\", \"c2\"], dtype=\"str\")\n",
    "print(cudfSeries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Testing for strings that match or contain a pattern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check whether elements contain a pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4     True\n",
       "5     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\"[0-9][a-z]\"\n",
    "\n",
    "pd.Series([\"1\", \"2\", \"3a\", \"3b\", \"03c\", \"4dx\"],dtype=\"str\",\n",
    "         ).str.contains(pattern)\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4     True\n",
       "5     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\"[0-9][a-z]\"\n",
    "\n",
    "cudf.Series([\"1\", \"2\", \"3a\", \"3b\", \"03c\", \"4dx\"],dtype=\"str\",\n",
    "         ).str.contains(pattern)\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Or whether elements match a pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4    False\n",
       "5     True\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([\"1\", \"2\", \"3a\", \"3b\", \"03c\", \"4dx\"],dtype=\"string\",\n",
    "         ).str.match(pattern)\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4    False\n",
       "5     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudf.Series([\"1\", \"2\", \"3a\", \"3b\", \"03c\", \"4dx\"],dtype=\"str\",\n",
    "         ).str.match(pattern) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "New in version 1.1.0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4    False\n",
       "5    False\n",
       "dtype: boolean"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([\"1\", \"2\", \"3a\", \"3b\", \"03c\", \"4dx\"],dtype=\"string\",\n",
    "         ).str.fullmatch(pattern)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4    False\n",
       "5     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cudf.Series([\"1\", \"2\", \"3a\", \"3b\", \"03c\", \"4dx\"],dtype=\"str\",\n",
    "         ).str.match(pattern)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In pandas, methods like `match`, `fullmatch`, `contains`, `startswith`, and `endswith` take an extra `na` argument so missing values can be considered `True` or `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings that contain 'A':\n",
      "0     True\n",
      "1    False\n",
      "2    False\n",
      "3     True\n",
      "4    False\n",
      "5    False\n",
      "6     True\n",
      "7    False\n",
      "8    False\n",
      "dtype: boolean\n",
      "\n",
      "Strings that have swapped case:\n",
      "0       a\n",
      "1       b\n",
      "2       c\n",
      "3    aABA\n",
      "4    bACA\n",
      "5    <NA>\n",
      "6    caba\n",
      "7     DOG\n",
      "8     CAT\n",
      "dtype: string\n",
      "\n",
      "Strings that start with 'b':\n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "4    False\n",
      "5     <NA>\n",
      "6    False\n",
      "7    False\n",
      "8    False\n",
      "dtype: boolean\n",
      "\n",
      "Strings that ends with 'a':\n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3     True\n",
      "4     True\n",
      "5     <NA>\n",
      "6    False\n",
      "7    False\n",
      "8    False\n",
      "dtype: boolean\n"
     ]
    }
   ],
   "source": [
    "pandasSeries5 = pd.Series([\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"], dtype=\"string\")   \n",
    "print(\"Strings that contain 'A':\")\n",
    "print(pandasSeries5.str.contains(\"A\", na=False))\n",
    "print(\"\\nStrings that have swapped case:\")\n",
    "print(pandasSeries5.str.swapcase())\n",
    "print(\"\\nStrings that start with 'b':\")\n",
    "print(pandasSeries5.str.startswith ('b'))\n",
    "print((\"\\nStrings that ends with 'a':\"))\n",
    "print(pandasSeries5.str.endswith ('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "cuDF does not have this extra parameter, so it will return `na`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings that contain 'A':\n",
      "0     True\n",
      "1    False\n",
      "2    False\n",
      "3     True\n",
      "4    False\n",
      "5     <NA>\n",
      "6     True\n",
      "7    False\n",
      "8    False\n",
      "dtype: bool\n",
      "\n",
      "Strings that have swapped case:\n",
      "0       a\n",
      "1       b\n",
      "2       c\n",
      "3    aABA\n",
      "4    bACA\n",
      "5    <NA>\n",
      "6    caba\n",
      "7     DOG\n",
      "8     CAT\n",
      "dtype: object\n",
      "\n",
      "Strings that start with 'b':\n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "4    False\n",
      "5     <NA>\n",
      "6    False\n",
      "7    False\n",
      "8    False\n",
      "dtype: bool\n",
      "\n",
      "Strings that ends with 'a':\n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3     True\n",
      "4     True\n",
      "5     <NA>\n",
      "6    False\n",
      "7    False\n",
      "8    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "cudfSeries5 = cudf.Series([\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"], dtype=\"str\")   \n",
    "print(\"Strings that contain 'A':\")\n",
    "print(cudfSeries5.str.contains(\"A\"))\n",
    "print(\"\\nStrings that have swapped case:\")\n",
    "print(cudfSeries5.str.swapcase())\n",
    "print(\"\\nStrings that start with 'b':\")\n",
    "print(cudfSeries5.str.startswith ('b'))\n",
    "print((\"\\nStrings that ends with 'a':\"))\n",
    "print(cudfSeries5.str.endswith ('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}