Pandas教程（非常详细）（第二部分）
接着Pandas教程（非常详细）（第一部分），继续讲述。
七、Pandas使用自定义函数
如果想要应用自定义的函数，或者把其他库中的函数应用到 Pandas 对象中，有以下三种方法：
- 1) 操作整个 DataFrame 的函数：pipe()
- 2) 操作行或者列的函数：apply()
- 3) 操作单一元素的函数：applymap()
如何从上述函数中选择适合的函数，这取决于函数的操作对象。下面介绍了三种方法的使用。
1、操作整个数据表 pipe()
通过给 pipe() 函数传递一个自定义函数和适当数量的参数值，从而操作 DataFrme 中的所有元素。下面示例，实现了数据表中的元素值依次加 3。
首先自定义一个函数，计算两个元素的加和，如下所示：
def adder(ele1,ele2):
return ele1+ele2然后使用自定义的函数对 DataFrame 进行操作：
df = pd.DataFrame(np.random.randn(4,3),columns=['c1','c2','c3'])
#传入自定义函数以及要相加的数值3
df.pipe(adder,3)在这里np.random.randn()的用法可以参考：numpy中几种随机数生成函数的用法-CSDN博客
完整的程序，如下所示：
import pandas as pd
import numpy as np
#自定义函数
def adder(ele1,ele2):
return ele1+ele2
#操作DataFrame
df = pd.DataFrame(np.random.randn(4,3),columns=['c1','c2','c3'])
#相加前
print(df)
#相加后
print(df.pipe(adder,3))输出结果：
c1 c2 c3
0 1.989075 0.932426 -0.523568
1 -1.736317 0.703575 -0.819940
2 0.657279 -0.872929 0.040841
3 0.441424 1.170723 -0.629618
c1 c2 c3
0 4.989075 3.932426 2.476432
1 1.263683 3.703575 2.180060
2 3.657279 2.127071 3.040841
3 3.441424 4.170723 2.370382
2、操作行或列 apply()
如果要操作 DataFrame 的某一行或者某一列，可以使用 apply() 方法，该方法与描述性统计方法类似，都有可选参数 axis，并且默认按列操作。示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
#默认按列操作，计算每一列均值
print(df.apply(np.mean))输出结果：
col1 0.277214
col2 0.716651
col3 -0.250487
dtype: float64
传递轴参 axis=1， 表示逐行进行操作，示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
print(df)
print (df.apply(np.mean,axis=1))输出结果：
col1 col2 col3
0 0.210370 -0.662840 -0.281454
1 -0.875735 0.531935 -0.283924
2 1.036009 -0.958771 -1.048961
3 -1.266042 -0.257666 0.403416
4 0.496041 -1.071545 1.432817
0 -0.244641
1 -0.209242
2 -0.323908
3 -0.373431
4 0.285771
dtype: float64
求每一列中，最大值与最小值之差。示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
print(df.apply(lambda x: x.max() - x.min()))输出结果:
col1 3.538252
col2 2.904771
col3 2.650892
dtype: float64
3、操作单一元素 applymap()
DataFrame 数据表结构的 applymap() 和 Series 系列结构的 map() 类似，它们都可以接受一个 Python 函数，并返回相应的值。
示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
#自定义函数lambda函数
print(df['col1'].map(lambda x:x*100))输出结果：
0 -18.171706
1 1.582861
2 22.398156
3 32.395690
4 -133.143543
Name: col1, dtype: float64
下面示例使用了 applymap() 函数，如下所示：
import pandas as pd
import numpy as np
#自定义函数
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
print(df.applymap(lambda x:x*10))
print(df.apply(np.mean))输出结果：
col1 col2 col3
0 -1.055926 7.952690 15.225932
1 9.362457 -12.230732 7.663450
2 2.910049 -2.782934 2.073905
3 -12.008132 -1.444989 5.988144
4 2.877850 6.563894 8.192513
#求均值：
col1 0.041726
col2 -0.038841
col3 0.782879
dtype: float64
八、Pandas reindex重置索引
重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。
1、重置行列标签
看一组简单示例：
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-07',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
#重置行、列索引标签
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])
print(df_reindexed)输出结果：
A C B
0 2020-12-07 Medium NaN
2 2020-12-09 Low NaN
5 2020-12-12 High NaN
现有 a、b 两个 DataFrame 对象，如果想让 a 的行索引与 b 相同，您可以使用 reindex_like() 方法。示例如下：
import pandas as pd
import numpy as np
a = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
b = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])
a= a.reindex_like(b)
print(a)输出结果：
col1 col2 col3
0 1.776556 -0.821724 -1.220195
1 -1.401443 0.317407 -0.663848
2 0.300353 -1.010991 0.939143
3 0.444041 -1.875384 0.846112
4 0.967159 0.369450 -0.414128
5 0.320863 -1.223477 -0.337110
6 -0.933665 0.909382 1.129481
上述示例，a 会按照 b 的形式重建行索引。需要特别注意的是，a 与 b 的列索引标签必须相同。
2、填充元素值
reindex_like() 提供了一个可选的参数method，使用它来填充相应的元素值，参数值介绍如下：
- pad/ffill：向前填充值；
- bfill/backfill：向后填充值；
- nearest：从距离最近的索引值开始填充。
示例如下：
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
#使df2和df1行标签相同
print(df2.reindex_like(df1))
#向前填充
print(df2.reindex_like(df1,method='ffill'))输出结果：
#填充前
col1 col2 col3
0 0.129055 0.835440 0.383065
1 -0.357231 0.379293 1.211549
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
#填充后
col1 col2 col3
0 0.129055 0.835440 0.383065
1 -0.357231 0.379293 1.211549
2 -0.357231 0.379293 1.211549
3 -0.357231 0.379293 1.211549
4 -0.357231 0.379293 1.211549
5 -0.357231 0.379293 1.211549
3、限制填充行数
reindex_like() 还提供了一个额外参数 limit，该参数用来控制填充的最大行数。示例如下：
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
print (df2.reindex_like(df1))
#最多填充2行
print (df2.reindex_like(df1,method='ffill',limit=2))输出结果：
#填充前
col1 col2 col3
0 0.129055 0.835440 0.383065
1 -0.357231 0.379293 1.211549
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
#填充后
col1 col2 col3
0 0.129055 0.835440 0.383065
1 -0.357231 0.379293 1.211549
2 -0.357231 0.379293 1.211549
3 -0.357231 0.379293 1.211549
4 NaN NaN NaN
5 NaN NaN NaN
由上述示例可以看出，填充了 2、3 行 缺失值，也就是只填充了 2 行数据。
4、重命名标签
rename() 方法允许您使用某些映射(dict或Series)或任意函数来对行、列标签重新命名，示例如下：
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print (df1)
#对行和列重新命名
print (df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},index = {0 : 'apple', 1 : 'banana', 2 : 'durian'}))输出结果：
col1 col2 col3
0 -1.762133 -0.636819 -0.309572
1 -0.093965 -0.924387 -2.031457
2 -1.231485 -0.738667 1.415724
3 -0.826322 0.206574 -0.731701
4 1.863816 -0.175705 0.491907
5 0.677361 0.870041 -0.636518
c1 c2 col3
apple -1.762133 -0.636819 -0.309572
banana -0.093965 -0.924387 -2.031457
durian -1.231485 -0.738667 1.415724
3 -0.826322 0.206574 -0.731701
4 1.863816 -0.175705 0.491907
5 0.677361 0.870041 -0.636518
rename() 方法提供了一个 inplace 参数，默认值为 False，表示拷贝一份原数据，并在复制后的数据上做重命名操作。若 inplace=True 则表示在原数据的基础上重命名。
九、Pandas iteration遍历
遍历是众多编程语言中必备的一种操作，比如 Python 语言通过 for 循环来遍历列表结构。那么 Pandas 是如何遍历 Series 和 DataFrame 结构呢？我们应该明确，它们的数据结构类型不同的，遍历的方法必然会存在差异。对于 Series 而言，您可以把它当做一维数组进行遍历操作；而像 DataFrame 这种二维数据表结构，则类似于遍历 Python 字典。
在 Pandas 中同样也是使用 for 循环进行遍历。通过for遍历后，Series 可直接获取相应的 value，而 DataFrame 则会获取列标签。示例如下：
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
print(df)
for col in df:
print (col)输出结果：
A
x
y
C
D
1、内置迭代方法
如果想要遍历 DataFrame 的每一行，我们下列函数：
- 1) iteritems()：以键值对 (key,value) 的形式遍历；
- 2) iterrows()：以 (row_index,row) 的形式遍历行;
- 3) itertuples()：使用已命名元组的方式对行遍历。
下面对上述函数做简单的介绍：
（1） iteritems()
以键值对的形式遍历 DataFrame 对象，以列标签为键，以对应列的元素为值。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
print (key,value)输出结果：
col1
0 0.561693
1 0.537196
2 0.882564
3 1.063245
Name: col1, dtype: float64
col2
0 -0.115913
1 -0.526211
2 -1.232818
3 -0.313741
Name: col2, dtype: float64
col3
0 0.103138
1 -0.655187
2 -0.101757
3 1.505089
Name: col3, dtype: float64
（2） iterrows()
该方法按行遍历，返回一个迭代器，以行索引标签为键，以每一行数据为值。示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3,3),columns = ['col1','col2','col3'])
print(df)
for row_index,row in df.iterrows():
print (row_index,row)输出结果：
col1 col2 col3
0 -0.319301 0.205636 0.247029
1 0.673788 0.874376 1.286151
2 0.853439 0.543066 -1.759512
0
col1 -0.319301
col2 0.205636
col3 0.247029
Name: 0, dtype: float64
1
col1 0.673788
col2 0.874376
col3 1.286151
Name: 1, dtype: float64
2
col1 0.853439
col2 0.543066
col3 -1.759512
Name: 2, dtype: float64
注意：iterrows() 遍历行，其中 0,1,2 是行索引而 col1,col2,col3 是列索引。
（3） itertuples
itertuples() 同样将返回一个迭代器，该方法会把 DataFrame 的每一行生成一个元组，示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(3,3),columns = ['c1','c2','c3'])
for row in df.itertuples():
print(row)输出结果：
Pandas(Index=0,c1=0.253902385555437,c2=0.9846386610838339,c3=0.8814786409138894) Pandas(Index=1,c1=0.018667367298908943,c2=0.5954745800963542,c3=0.04614488622991075)
Pandas(Index=2,c1=0.3066297875412092,c2=0.17984210928723543,c3=0.8573031941082285)
2、迭代返回副本
迭代器返回的是原对象的副本，所以，如果在迭代过程中修改元素值，不会影响原对象，这一点需要大家注意。
看一组简单的示例：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3,3),columns = ['col1','col2','col3'])
for index, row in df.iterrows():
row['a'] = 15
print (df)输出结果：
col1 col2 col3
0 1.601068 -0.098414 -1.744270
1 -0.432969 -0.233424 0.340330
2 -0.062910 1.413592 0.066311
由上述示例可见，原对象df没有受到任何影响。
十、Pandas sorting排序
Pands 提供了两种排序方法，分别是按标签排序和按数值排序。本节讲解 Pandas 的排序操作。
下面创建一组 DataFrame 数据，如下所示：
import pandas as pd
import numpy as np
#行标签乱序排列，列标签乱序排列
unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,6,4,2,3,5,9,8,0,7],columns=['col2','col1'])
print(unsorted_df)输出结果：
col2 col1
1 -0.053290 -1.442997
6 -0.203066 -0.702727
4 0.111759 0.965251
2 -0.896778 1.100156
3 -0.458899 -0.890152
5 -0.222691 -0.144881
9 -0.921674 0.510045
8 -0.130748 -0.734237
0 0.617717 0.456848
7 0.804284 0.653961
上述示例，行标签和数值元素均未排序，下面分别使用标签排序、数值排序对其进行操作。
1、按标签排序
使用 sort_index() 方法对行标签排序，指定轴参数（axis）或者排序顺序。或者可以对 DataFrame 进行排序。默认情况下，按照行标签序排序。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],columns = ['col2','col1'])
sorted_df=unsorted_df.sort_index()
print(sorted_df)输出结果：
col2 col1
0 2.113698 -0.299936
1 -0.550613 0.501497
2 0.056210 0.451781
3 0.074262 -1.249118
4 -0.038484 -0.078351
5 0.812215 -0.757685
6 0.687233 -0.356840
7 -0.483742 0.632428
8 -1.576988 -1.425604
9 0.776720 1.182877
（1）排序顺序
通过将布尔值传递给ascending参数，可以控制排序的顺序（行号顺序）。示例如下：
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],columns = ['col2','col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print(sorted_df)输出结果：
col2 col1
9 2.389933 1.152328
8 -0.374969 0.182293
7 -0.823322 -0.104431
6 -0.566627 -1.020679
5 1.021873 0.315927
4 0.127070 -1.598591
3 0.258097 0.389310
2 -1.027768 -0.582664
1 0.766471 -0.043638
0 0.482486 -0.512309
2、按列标签排序
通过给 axis 轴参数传递 0 或 1，可以对列标签进行排序。默认情况下，axis=0 表示按行排序；而 axis=1 则表示按列排序。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],columns = ['col2','col1'])
sorted_df=unsorted_df.sort_index(axis=1)
print (sorted_df)输出结果：
col1 col2
1 -1.424992 -0.062026
4 -0.083513 1.884481
6 -1.335838 0.838729
2 -0.085384 0.178404
3 1.198965 0.089953
5 1.400264 0.213751
9 -0.992759 0.015740
8 1.586437 -0.406583
0 -0.842969 0.490832
7 -0.310137 0.485835
3、按值排序
与标签排序类似，sort_values() 表示按值排序。它接受一个by参数，该参数值是要排序数列的 DataFrame 列名。示例如下：
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1')
print (sorted_df)输出结果：
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1
注意：当对 col1 列排序时，相应的 col2 列的元素值和行索引也会随 col1 一起改变。by 参数可以接受一个列表参数值，如下所示：
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print (sorted_df）输出结果：
col1 col2
2 1 2
1 1 3
3 1 4
0 2 1
4、排序算法
sort_values() 提供了参数kind用来指定排序算法。这里有三种排序算法：
- mergesort
- heapsort
- quicksort
默认为 quicksort(快速排序) ，其中 Mergesort 归并排序是最稳定的算法。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print (sorted_df)输出结果：
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1
十一、Pandas去重函数：drop_duplicates()
“去重”通过字面意思不难理解，就是删除重复的数据。在一个数据集中，找出重复的数据删并将其删除，最终只保存一个唯一存在的数据项，这就是数据去重的整个过程。删除重复数据是数据分析中经常会遇到的一个问题。通过数据去重，不仅可以节省内存空间，提高写入性能，还可以提升数据集的精确度，使得数据集不受重复数据的影响。
Panda DataFrame 对象提供了一个数据去重的函数 drop_duplicates()，本节对该函数的用法做详细介绍。
1、函数格式
drop_duplicates()函数的语法格式如下：
df.drop_duplicates(subset=['A','B','C'],keep='first',inplace=True)参数说明如下：
- subset：表示要进去重的列名，默认为 None。
- keep：有三个可选参数，分别是 first、last、False，默认为 first，表示只保留第一次出现的重复项，删除其余重复项，last 表示只保留最后一次出现的重复项，False 则表示删除所有重复项。
- inplace：布尔值参数，默认为 False 表示删除重复项后返回一个副本，若为 Ture 则表示直接在原数据上删除重复项。
2、实际应用
首先创建一个包含有重复值的 DataFrame 对象，如下所示：
import pandas as pd
data={
'A':[1,0,1,1],
'B':[0,2,5,0],
'C':[4,0,4,4],
'D':[1,0,1,1]
}
df=pd.DataFrame(data=data)
print(df)输出结果：
A B C D
0 1 0 4 1
1 0 2 0 0
2 1 5 4 1
3 1 0 4 1
（1） 默认保留第一次出现的重复项
import pandas as pd
data={
'A':[1,0,1,1],
'B':[0,2,5,0],
'C':[4,0,4,4],
'D':[1,0,1,1]
}
df=pd.DataFrame(data=data)
#默认保留第一次出现的重复项
df.drop_duplicates()输出结果：
A B C D
0 1 0 4 1
1 0 2 0 0
2 1 5 4 1
（2） keep=False删除所有重复项
import pandas as pd
data={
'A':[1,0,1,1],
'B':[0,2,5,0],
'C':[4,0,4,4],
'D':[1,0,1,1]
}
df=pd.DataFrame(data=data)
#默认保留第一次出现的重复项
df.drop_duplicates(keep=False)输出结果：
A B C D
1 0 2 0 0
2 1 5 4 1
（3） 根据指定列标签去重
import pandas as pd
data={
'A':[1,3,3,3],
'B':[0,1,2,0],
'C':[4,5,4,4],
'D':[3,3,3,3]
}
df=pd.DataFrame(data=data)
#去除所有重复项，对于B列来说两个0是重复项
df.drop_duplicates(subset=['B'],keep=False)
#简写，省去subset参数
#df.drop_duplicates(['B'],keep=False)
print(df)输出结果：
A B C D
1 3 1 5 3
2 3 2 4 3
从上述示例可以看出，删除重复项后，行标签使用的数字是原来的，并没有从 0 重新开始，那么我们应该怎么从 0 重置索引呢？Pandas 提供的 reset_index() 函数会直接使用重置后的索引。如下所示：
import pandas as pd
data={
'A':[1,3,3,3],
'B':[0,1,2,0],
'C':[4,5,4,4],
'D':[3,3,3,3]
}
df=pd.DataFrame(data=data)
#去除所有重复项，对于B来说两个0是重复项
df=df.drop_duplicates(subset=['B'],keep=False)
#重置索引，从0重新开始
df.reset_index(drop=True)输出结果：
A B C D
0 3 1 5 3
1 3 2 4 3
（4） 指定多列同时去重
创建一个 DataFrame 对象，如下所示：
import numpy as np
import pandas as pd
df = pd.DataFrame({'Country ID':[1,1,2,12,34,23,45,34,23,12,2,3,4,1],
'Age':[12,12,15,18, 19, 25, 21, 25, 25, 18, 25,12,32,18],
'Group ID':['a','z','c','a','b','s','d','a','b','s','a','d','a','f']})
#last只保留最后一个重复项
df.drop_duplicates(['Age','Group ID'],keep='last')输出结果：
Country ID Age Group ID
0 1 12 a
1 1 12 z
2 2 15 c
3 3 18 a
4 4 19 b
5 3 25 s
6 4 21 d
8 2 25 b
9 1 18 s
10 2 25 a
11 3 12 d
12 4 32 a
13 1 18 f
上述数据集中，第 7 行、第 10 行对应的列标签数据相同，我们使用参数值“last”保留最后一个重复项，也就是第 10 行数据。
十二、Python Pandas处理字符串（方法详解）
Pandas 提供了一系列的字符串函数，因此能够很方便地对字符串进行处理。在本节，我们使用 Series 对象对常用的字符串函数进行讲解。
常用的字符串处理函数如下表所示：
| 函数名称 | 函数功能和描述 |
|---|---|
| lower() | 将的字符串转换为小写。 |
| upper() | 将的字符串转换为大写。 |
| len() | 得出字符串的长度。 |
| strip() | 去除字符串两边的空格（包含换行符）。 |
| split() | 用指定的分割符分割字符串。 |
| cat(sep="") | 用给定的分隔符连接字符串元素。 |
| get_dummies() | 返回一个带有独热编码值的 DataFrame 结构。 |
| contains(pattern) | 如果子字符串包含在元素中，则为每个元素返回一个布尔值 True，否则为 False。 |
| replace(a,b) | 将值 a 替换为值 b。 |
| count(pattern) | 返回每个字符串元素出现的次数。 |
| startswith(pattern) | 如果 Series 中的元素以指定的字符串开头，则返回 True。 |
| endswith(pattern) | 如果 Series 中的元素以指定的字符串结尾，则返回 True。 |
| findall(pattern) | 以列表的形式返出现的字符串。 |
| swapcase() | 交换大小写。 |
| islower() | 返回布尔值，检查 Series 中组成每个字符串的所有字符是否都为小写。 |
| issupper() | 返回布尔值，检查 Series 中组成每个字符串的所有字符是否都为大写。 |
| isnumeric() | 返回布尔值，检查 Series 中组成每个字符串的所有字符是否都为数字。 |
| repeat(value) | 以指定的次数重复每个元素。 |
| find(pattern) | 返回字符串第一次出现的索引位置。 |
注意：上述所有字符串函数全部适用于 DataFrame 对象，同时也可以与 Python 内置的字符串函数一起使用，这些函数在处理 Series/DataFrame 对象的时候会自动忽略缺失值数据（NaN）。
1、lower()
将的字符串转换为小写。
import pandas as pd
import numpy as np
s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
print(s.str.lower)输出结果：
0 tom
1 william rick
2 john
3 alber@t
4 NaN
5 1234
6 stevesmith
dtype: object
2、len()
得出字符串的长度。
import pandas as pd
import numpy as np
s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
print(s.str.len())输出结果：
0 1.0
1 6.0
2 4.0
3 2.0
4 NaN
5 4.0
6 10.0
dtype: float64
3、strip()
去除字符串两边的空格（包含换行符）。
import pandas as pd
import numpy as np
s = pd.Series(['C ', ' Python', 'java', 'go', np.nan, '1125 ','javascript'])
print(s.str.strip())输出结果：
0 C
1 Python
2 java
3 go
4 NaN
5 1125
6 javascript
dtype: object
4、split(pattern)
用指定的分割符分割字符串。
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.split(" "))输出结果：
0 [C, ]
1 [, Python]
2 [java]
3 [go]
4 [1125, ]
5 [javascript]
dtype: object
5、cat(sep="")
用给定的分隔符连接字符串元素。
import pandas as pd
import numpy as np
s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
#会自动忽略NaN
print(s.str.cat(sep="_"))输出结果：
C_Python_java_go_1125_javascript
6、get_dummies()
返回一个带有独热编码值的 DataFrame 结构。
import pandas as pd
import numpy as np
s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
print(s.str.get_dummies())输出结果：
1125 C Python go java javascript
0 0 1 0 0 0 0
1 0 0 1 0 0 0
2 0 0 0 0 1 0
3 0 0 0 1 0 0
4 0 0 0 0 0 0
5 1 0 0 0 0 0
6 0 0 0 0 0 1
7、contains()
检查 Series 中的每个字符，如果字符中包含空格，则返回 True，否则返回 False。示例如下：
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.contains(" "))输出结果：
0 True
1 True
2 False
3 False
4 True
5 False
dtype: bool
8、repeat()
以指定的次数重复每个元素。
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.repeat(3))输出结果：
0 C C C
1 Python Python Python
2 javajavajava
3 gogogo
4 1125 1125 1125
5 javascriptjavascriptjavascript
dtype: object
9、startswith()
如果 Series 中的元素以指定的字符串开头，则返回 True。
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
#若以指定的"j"开头则返回True
print(s.str.startswith("j"))输出结果：
0 False
1 False
2 True
3 False
4 False
5 True
dtype: bool
10、find()
返回字符串第一次出现的索引位置。
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.find("j"))输出结果：
0 -1
1 -1
2 0
3 -1
4 -1
5 0
dtype: int64
如果返回 -1 表示该字符串中没有出现指定的字符。
11、findall()
以列表的形式返出现的字符串。
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.findall("j"))输出结果：
0 []
1 []
2 [j]
3 []
4 []
5 [j]
dtype: object
12、swapcase()
交换大小写。
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125 ','javascript'])
print(s.str.swapcase())输出结果：
0 c
1 pYTHON
2 JAVA
3 GO
4 1125
5 JAVASCRIPT
dtype: object
13、isnumeric()
返回一个布尔值，用来判断是否存在数字型字符串。示例如下：
import pandas as pd
import numpy as np
s = pd.Series(['C ',' Python','java','go','1125','javascript'])
print(s.str.isnumeric())输出结果：
0 False
1 False
2 False
3 False
4 True
5 False
dtype: bool
后面内容将在Pandas教程（非常详细）（第三部分），继续讲述。