Pandas字符串和文本数据.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "lower() 将series/index 中的字符串转换为小写\n",
    "upper() 将series/index 中的字符串转换为大写\n",
    "len() 计算字符串的长度\n",
    "strip() 帮助从两侧的series/index中的每个字符串中删除空格(包括换行符)\n",
    "split(' ') 用给定的模式拆分每个字符串，并以list的形式返回\n",
    "cat(sep=' ') 使用给定的分隔符连接series/index元素\n",
    "get_dummies() 返回具有单热编码值的DataFrame\n",
    "contains(pattern) 如果元素中包含字符串，则返回每个元素的布尔值True，否则为False\n",
    "replace(a,b) 将a的值替换为b\n",
    "repeat(value) 重复每个元素的指定次数\n",
    "count()模式中每个元素出现的总数\n",
    "startswith(pattern) 如果series/index中的元素以模式开始，则返回True\n",
    "endswith(pattern) 如果series/index中的元素以模式结尾，则返回True\n",
    "find(pattern) 返回模式第一次出现的位置\n",
    "findall(pattern) 返回模式的所有出现的列表\n",
    "swapcase() 变换字母大小写\n",
    "islower() 检查series/index中的每个字符串中的所有字符是否小写，返回布尔值\n",
    "isupper() 检查series/index中的每个字符串中的所有字符是否大写，返回布尔值\n",
    "isnumeric() 检查series/index中的每个字符串中的所有字符是否数字，返回布尔值\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             Tom\n",
      "1    William Rick\n",
      "2            John\n",
      "3         Alber@t\n",
      "4             NaN\n",
      "5            1234\n",
      "6      SteveMinsu\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveMinsu'])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             tom\n",
      "1    william rick\n",
      "2            john\n",
      "3         alber@t\n",
      "4             NaN\n",
      "5            1234\n",
      "6      steveminsu\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# lower() 将字符串中的所有字符转为小写\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveMinsu'])\n",
    "\n",
    "print (s.str.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             TOM\n",
      "1    WILLIAM RICK\n",
      "2            JOHN\n",
      "3         ALBER@T\n",
      "4             NaN\n",
      "5            1234\n",
      "6      STEVEMINSU\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# upper() 将所有的字符转为大写\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom','William Rick','John','Alber@t',np.nan,'1234','SteveMinsu'])\n",
    "print(s.str.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     3.0\n",
      "1    12.0\n",
      "2     4.0\n",
      "3     7.0\n",
      "4     NaN\n",
      "5     4.0\n",
      "6    10.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# len() 计算字符串中的字符的个数\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveMinsu'])\n",
    "print (s.str.len())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             Tom \n",
      "1     William Rick\n",
      "2             John\n",
      "3          Alber@t\n",
      "dtype: object\n",
      "=========== After Stripping ================\n",
      "0             Tom\n",
      "1    William Rick\n",
      "2            John\n",
      "3         Alber@t\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "#strip() 删除Series/index两侧中的空格或者换行符\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (s)\n",
    "print (\"=========== After Stripping ================\")\n",
    "print (s.str.strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             Tom \n",
      "1     William Rick\n",
      "2             John\n",
      "3          Alber@t\n",
      "dtype: object\n",
      "================= Split Pattern: ==================\n",
      "0              [Tom, ]\n",
      "1    [, William, Rick]\n",
      "2               [John]\n",
      "3            [Alber@t]\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# split() 以指定的模式切割字符串\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (s)\n",
    "print (\"================= Split Pattern: ==================\")\n",
    "print (s.str.split(' '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom  <=>  William Rick <=> John <=> Alber@t\n"
     ]
    }
   ],
   "source": [
    "# cat(sep = pattern) 以指定的模式连接字符串\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "\n",
    "print (s.str.cat(sep=' <=> '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    William Rick  Alber@t  John  Tom \n",
      "0              0        0     0     1\n",
      "1              1        0     0     0\n",
      "2              0        0     1     0\n",
      "3              0        1     0     0\n"
     ]
    }
   ],
   "source": [
    "#get_dummies() 返回具有单热编码值的DataFrame\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "\n",
    "print (s.str.get_dummies())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     True\n",
      "1     True\n",
      "2    False\n",
      "3    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# contain(pattern) 查看字符串中是否有指定模式的字符，若有返回True，否则返回False\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (s.str.contains(' '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             Tom \n",
      "1     William Rick\n",
      "2             John\n",
      "3          Alber@t\n",
      "dtype: object\n",
      "After replacing @ with $: ============== \n",
      "0             Tom \n",
      "1     William Rick\n",
      "2             John\n",
      "3          Alber$t\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# replace(a,b) 替换a为b\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (s)\n",
    "print (\"After replacing @ with $: ============== \")\n",
    "print (s.str.replace('@','$'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0                      Tom Tom \n",
      "1     William Rick William Rick\n",
      "2                      JohnJohn\n",
      "3                Alber@tAlber@t\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# repeat(number) 指定字符串重复的次数\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "\n",
    "print (s.str.repeat(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of 'm's in each string:\n",
      "0    1\n",
      "1    1\n",
      "2    0\n",
      "3    0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# count(pattern) 查看整个字符串中指定字符出现的次数\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "\n",
    "print (\"The number of 'm's in each string:\")\n",
    "print (s.str.count('m'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings that start with 'T':\n",
      "0     True\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# startswith(pattern) 查看字符串是否以指定的字符开始，返回布尔值\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "\n",
    "print (\"Strings that start with 'T':\")\n",
    "print (s.str. startswith ('T'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings that end with 't':\n",
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3     True\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# endswith(pattern) 查看字符串是否以指定的字符串结尾，返回布尔值\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (\"Strings that end with 't':\")\n",
    "print (s.str.endswith('t'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0   -1\n",
      "1   -1\n",
      "2   -1\n",
      "3    3\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# find(pattern) 查找指定字符在字符串中第一次出现的位置,若返回-1则表示没有这样的模式\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (s.str.find('e'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     []\n",
      "1     []\n",
      "2     []\n",
      "3    [e]\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# findall(pattern) 查看字符串中是否存在指定字符，若有返回指定字符，没有则返回空list\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])\n",
    "print (s.str.findall('e'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0             tOM\n",
      "1    wILLIAM rICK\n",
      "2            jOHN\n",
      "3         aLBER@T\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# swapcase() 将字符串中的字符串变换大小写\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])\n",
    "print (s.str.swapcase())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# islower() 查看字符串中的字符是否为全都小写，返回布尔值\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])\n",
    "print (s.str.islower())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     True\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# isupper() 查看字符串中的字符是否为全都大写，返回布尔值\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.Series(['TOM', 'William Rick', 'John', 'Alber@t'])\n",
    "\n",
    "print (s.str.isupper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    False\n",
      "1     True\n",
      "2    False\n",
      "3    False\n",
      "4    False\n",
      "dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# isnumeric() 查看字符串中的字符是否全都为数字\n",
    "import pandas as pd\n",
    "s = pd.Series(['Tom', '1199','William Rick', 'John', 'Alber@t'])\n",
    "print (s.str.isnumeric())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}