一、数据清洗
1.1、dropna()
删除包含NaN值的行。
series.dropna(axis=0, inplace=False)| 描述 | 说明 |
| axis | 可选参数，用于指定按哪个轴删除缺失值。对于 Series对象，因为它是 一维数据结构，只有一个轴，所以此参数默认值为0，且一般不需要修改这个参 数（在处理 DataFrame时该参数才有更多实际意义，如 除，axis = 1表示按列删除）。 |
| inplace | 可选参数，用于指定是否在原 inplace = True，则会直接在原 axis = 0表示按行删 Series对象上进行操作。如果 如果 Series上删除缺失值，原 Series会被修改； inplace = False（默认值），则会返回一个删除了缺失值的新 Series， 原Series保持不变。 |
|---|
python
import pandas as pd
import numpy as np
data = [1, np.nan, 3, 4, np.nan]
series = pd.Series(data)
new_series = series.dropna()
print(new_series)
python
0 1.0
2 3.0
3 4.0
dtype: float641.2、fillna()
填充NaN值。
python
Series.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)| 描述 | 说明 |
| value | 用于填充缺失值的标量值或字典。如果传递的是字典，则字典的键应该 是要填充的标签，值是用于填充的值。 |
| method | 字符串，表示填充的方法。可选值包括： pad / ffill：用前一个非缺失值去填充缺失值。 bfill / backfill：用后一个非缺失值去填充缺失值。 |
| axis | 填充的轴，对于Series 对象来说，这个参数通常不需要指定，因为Series 是一维的。 |
| inplace | 布尔值，表示是否在原地修改数据。如果为True，则直接在原 Series 上修改，不返回新的对象。 |
| limit | 整数，表示最大填充量。如果指定，则只填充前 limit 个缺失值。 |
| downcast | 字典，用于向下转换数据类型。例如，可以将float64 转换为float32 |
|---|
python
import pandas as pd
import numpy as np
s = pd.Series([1, np.nan, 3, np.nan, 5])
filled_with_scalar = s.fillna(0)
print(filled_with_scalar)
filled_with_ffill = s.fillna(method='ffill')
print(filled_with_ffill)
filled_with_bfill = s.fillna(method='bfill')
print(filled_with_bfill)
filled_with_limit = s.fillna(value=0, limit=1)
print(filled_with_limit)
python
0 1.0
1 0.0
2 3.0
3 0.0
4 5.0
dtype: float64
0 1.0
1 1.0
2 3.0
3 3.0
4 5.0
dtype: float64
0 1.0
1 3.0
2 3.0
3 5.0
4 5.0
dtype: float64
0 1.0
1 0.0
2 3.0
3 NaN
4 5.01.3、isnull()
检测Series对象中的缺失值，它会返回一个布尔型Series，其中每个元 素表示原Series对应位置的值是否为缺失值（NaN）。
python
Series.isnull()
python
import pandas as pd
import numpy as np
s = pd.Series([1, 2, np.nan, 4, np.nan])
missing_values = s.isnull()
print(missing_values)
python
0 False
1 False
2 True
3 False
4 True
dtype: bool1.4、drop_duplicates()
用于去除Series对象中的重复项。
python
Series.drop_duplicates(keep='first', inplace=False, ignore_index=False)| 描述 | 说明 |
| keep | 可选参数，决定了如何处理重复项。有三个选项： | 'first' | 默认值，保留第一次出现的重复项。 | | 'last' | 保留最后一次出现的重复项。 | | False | 不保留任何重复项，即删除所有重复项。 | |---------|--------------------| |
| inplace | 布尔值，默认为False.。如果设置为True,则直接在原始Series上进行操作，返回值为None。如果设置为False,则返回一个新的Series，不修改原始Series。 |
| ignore_index | 布尔值，默认为 False。如果设置为 True，则结果的索引将被 重新设置，以反映删除重复项后的新顺序。如果设置为False，则保留原始索引。 |
|---|
python
import pandas as pd
series = pd.Series(['a', 'b', 'b', 'c', 'c', 'c', 'd'])
series_unique = series.drop_duplicates(keep='first')
print(series_unique)
python
0 a
1 b
3 c
6 d
dtype: object二、数据转换
2.1、replace()
替换特定的值、一系列值或者使用字典映射进行替换。
python
Series.replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad')| 描述 | 说明 |
| to_replace | 要替换的值，可以是以下类型： | 标量 | 单个值。 | | 列表 | 一系列值。 | | 字典 | 键是要替换的值，值是替换后的新值。 | | 正则表达式 | 如果 regex=True，则可以使用正则表达式匹配要替换的值。 | |-------|----------------------------------| |
| value | 替换后的新值，可以是标量或字典。如果 to_replace 是列表，则value 也应该是相同长度的列表。 |
| inplace | 布尔值，表示是否在原地修改数据。如果为 True，则直接在原 Series 上修改，不返回新的对象。 |
| limit | 整数，表示最大替换量。如果指定，则只替换前limit 个匹配的值。 |
| regex | 布尔值，表示是否将to_replace 解释为正则表达式。 |
| method | 字符串，表示填充的方法，在 to_replace 参数是一个标量、列表或 元组，同时 value 参数设置为 None 时，可以使用method 参数来指定填充缺 失值（NaN）的方式。可选值包括： | pad /ffill | 用前一个非缺失值去填充缺失值。 | | bfill | 用后一个非缺失值去填充缺失值。 | |------------|-----------------| |
|------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
python
import pandas as pd
s = pd.Series([1, 2, 3, 4, 5])
replaced = s.replace(to_replace=2, value=20)
print(replaced)
python
0 1
1 20
2 3
3 4
4 5
dtype: int642.2、astype()
用于将 Series 的数据类型（dtype）转换或转换为另一种类型。
python
Series.astype(dtype, copy=True, errors='raise')| 描述 | 说明 |
| dtype | 你希望将 Series 转换成的数据类型。 |
| copy | 布尔值，默认为 True。如果为 False，则转换数据类型时不会复制底层 数据（如果可能的话）。 |
| errors | 默认为 'raise'，控制当转换失败时的行为。如果设置为 'raise'，则在转 换失败时会抛出异常；如果设置为 'ignore'，转换失败后则返回原始Series，不做任何修改。 |
|---|
python
import pandas as pd
s = pd.Series([1, 2, 3, 4, 5])
s_str = s.astype(float)
print(s_str)
python
0 1.0
1 2.0
2 3.0
3 4.0
4 5.0
dtype: float642.3、transform()
用于对Series中的数据进行转换操作，并返回与原始Series具有相 同索引的新Series。
python
Series.transform(func, axis=0, *args, **kwargs)| 描述 | 说明 |
| func | 应用于Series的函数。这个函数可以是内置函数，或者自定义的函数。 |
| axis | 对于Series来说，这个参数不起作用，因为Series是一维的。在 DataFrame上使用时， axis=0（默认）表示按列应用函数， axis=1表示按行应 用函数。 |
| *args, **kwargs | 这些参数会被传递给func函数。 |
|---|
python
import pandas as pd
def square(x):
return x ** 2
s = pd.Series([1, 2, 3, 4, 5])
transformed_series = s.transform(square)
print(transformed_series)
python
0 1
1 4
2 9
3 16
4 25
dtype: int64三、数据排序
3.1、sort_values()
按照值对 Series 进行排序。
python
Series.sort_values(axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)| 描述 | 说明 |
| axis | 默认为 0。对于 Series，这个参数不起作用，因为 Series 是一维的，而 sort_values 总是在 axis=0 上操作。 |
| ascending | 布尔值，默认为True。如果是True，则按照升序排列；如果是False，则按照降序排列。 |
| inplace | 布尔值，默认为False。如果为 True，则排序将直接在原始 Series上进行，不返回新的 Series。 |
| kind | 排序算法，{'quicksort', 'mergesort', 'heapsort', 'stable'}，默认为'quicksort'。决定了使用的排序算法。 |
| na_position | {'first', 'last'}，默认为 'last'。这决定了 NaN 值的放置位置。 |
| ignore_index | 布尔值，默认为 False。如果为 True，则排序后的 Series 将重置索引，使其成为默认的整数索引。 |
| key | 函数，默认为 None。如果指定，则这个函数将在排序之前应用于每个值， 并且排序将基于这些函数返回的值。 |
|---|
python
import pandas as pd
import numpy as np
def square(x):
return x ** 2
s = pd.Series([-3, 1, 4, 1, np.nan, 9], index=['a', 'b', 'c', 'd', 'e', 'f'])
sorted_s = s.sort_values(ignore_index=True, key=square)
print(sorted_s)
python
0 1.0
1 1.0
2 -3.0
3 4.0
4 9.0
5 NaN
dtype: float643.2、sort_index()
按照索引的顺序对数据进行排序。
python
Series.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None)| 描述 | 说明 |
| axis | 默认为 0。对于 Series，这个参数不起作用 |
| level | 默认为 None，如果索引是多级索引（也称为层次化索引或 MultiIndex），则可以指定要排序的级别。 |
| ascending | 默认为 True，如果为 True，则按升序排序；如果为 False，则按降 序排序。对于多级索引，可以传递一个布尔值列表，以指定每个级别的排序顺 序。 |
| inplace | 默认为 False，如果为 True，则直接在原对象上进行修改，不会返回一 个新的对象。 |
| kind | {'quicksort', 'mergesort', 'heapsort'}，默认为 'quicksort'，指定排序算 法。'quicksort' 是最快的通用排序算法，但不是稳定的；'mergesort' 是稳定的， 但可能比 'quicksort' 慢；'heapsort' 是原地排序算法，但通常比其他两个选项 慢。 |
| na_position | {'first', 'last'}, 默认为 'last'，指定 NaN 值应该排在排序结果的开头 还是结尾。 |
| sort_remaining | 默认为 True，对于多级索引，如果为 True，在该level排序 后，在排序的基础上对剩下的级别的元素还会排序。 |
| ignore_index | 默认为 False，如果为 True，则排序后的结果将不再保留原始索 引，而是使用默认的整数索引。 |
| key | 函数，默认为 None。如果指定，则这个函数将在排序之前应用于每个值， 并且排序将基于这些函数返回的值。 |
|---|
python
import pandas as pd
import numpy as np
arrays = [
np.array(['qux', 'qux', 'foo', 'foo','baz', 'baz', 'bar', 'bar']),
np.array(['two', 'one', 'two', 'one','two', 'one', 'two', 'one'])
]
s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays)
print(s)
res = s.sort_index(level=1, ascending=True, sort_remaining=True, ignore_index=False)
print(res)
python
qux two 1
one 2
foo two 3
one 4
baz two 5
one 6
bar two 7
one 8
dtype: int64
bar one 8
baz one 6
foo one 4
qux one 2
bar two 7
baz two 5
foo two 3
qux two 1
dtype: int64四、数据筛选
可以使用一个布尔数组来选择满足条件的元素。
python
import pandas as pd
series = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print(series[series > 30])
python
d 40
e 50
dtype: int64五、数据拼接
concat()：用于将多个Pandas对象（如Series或DataFrame）沿着一个轴连接起来的 函数。
python
pandas.concat(objs, *, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=None)| 描述 | 说明 |
| objs | 参与连接的Pandas对象的列表或元组。例如，可以是多个Series或 DataFrame。 |
| axis | {0或'index', 1或'columns'}，表示连接的轴，默认为0。0表示沿着行方向 连接（索引轴），1表示沿着列方向连接（列轴）。 |
| join | {'inner', 'outer'}，默认为'outer'。如何处理其他轴上的索引。'outer'表示 并集，保留所有索引；'inner'表示交集，只保留所有对象共有的索引。 |
| ignore_index | 布尔值，默认为False。如果为True，则不保留原索引，而是创 建一个新索引，可以避免重复的索引。 |
| keys | 序列，默认为None。用于创建分层索引的键。如果提供了keys，则生成 的DataFrame或Series将具有分层索引。 |
| levels | 序列列表，默认为None。用于构造分层索引的特定级别，如果设置了 keys，则默认为keys。 |
| names | 列表，默认为None。生成的分层索引中的级别名称。如果提供了keys， 表示使用keys作为索引名称。 |
| verify_integrity | 布尔值，默认为False。如果为True，则检查新连接的轴是 否包含重复的索引，如果发现重复，则引发ValueError。这在确保数据没有重复 时很有用。 |
| sort | 布尔值，默认为False。在连接之前是否对非连接轴上的索引进行排序。这 在连接多个DataFrame时很有用，可以确保索引是有序的。 |
| copy | 布尔值，默认为None。如果为True，则不管是否需要，都会复制数据。 如果为False，则尽量避免复制数据，除非必要。None表示自动选择。 |
|---|
python
import pandas as pd
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5, 6], index=['c', 'd', 'f'])
s3 = pd.Series([7, 8, 9], index=['e', 'f', 'g'])
result = pd.concat([s1, s2, s3])
print(result)
python
a 1
b 2
c 3
c 4
d 5
f 6
e 7
f 8
g 9
dtype: int64六、思维导图
