数据仓库与数据挖掘实验练习4-5（实验三2024.5.15）

本文链接：https://blog.csdn.net/qq_64684039/article/details/138889426

练习4：DataFrame

排序

sort_values(by=column_name): 根据指定列的值对DataFrame进行排序。
ascending=False: 降序排序。
可以根据多列排序，并指定每个列的排序方式。
sort_index(): 根据索引标签排序。
axis=1: 按列排序 (默认 axis=0 按行排序).

1.sort_values()函数:用于根据DataFrame的一列或多列的值进行排序。

nba.sort_values(by='Name'):按"Name"列升序排序。
nba.sort_values('Name',ascending=False):按"Name"列降序排序。
nba.sort_values('Birthday',ascending=False):按"Birthday"列降序排序。
nba.sort_values(by=['Team','Name']):先按"Team"列升序排序，然后在每个"Team"组内按"Name"列升序排序。
nba.sort_values(by=['Team','Name'],ascending=[True,False]):先按"Team"列升序排序，然后在每个"Team"组内按"Name"列降序排序。
nba=nba.sort_values(by=['Team','Salary'],ascending=[True,False]):先按"Team"列升序排序，然后在每个"Team"组内按"Salary"列降序排序，并将排序后的结果赋值回nba变量。

2.sort_index()函数:用于根据DataFrame的索引标签进行排序。

nba.sort_index():按索引标签升序排序。
nba.sort_index(ascending=False):按索引标签降序排序。
nba=nba.sort_index():按索引标签升序排序，并将排序后的结果赋值回nba变量，恢复到初始状态。
nba.sort_index(axis=1):按列索引标签升序排序。
nba.sort_index(axis=1,ascending=False):按列索引标签降序排序。

3.set_index()函数:用于将DataFrame的某一列设置为索引。

#设置index
#nba.set_index(keys='Name')
nba.set_index('Name')
nba = nba.set_index(keys='Name')

4.pd.read_csv()函数:用于读取CSV文件，并将其转换为DataFrame。
nba2=pd.read_csv('nba.csv',parse_dates=['Birthday'],index_col='Name'):读取"nba.csv"文件，将"Birthday"列解析为日期时间类型，并将"Name"列设置为索引。

5.delnba2:删除nba2变量，释放内存。

选择指定的行和列

在 Pandas 中，可以使用方括号 [] 或点号 . 选择列，但方括号更为通用。
选择单列返回 Series 对象，选择多列返回 DataFrame 对象。
可以使用 select_dtypes() 函数按数据类型选择列。
可以使用 loc 属性根据索引标签选择行，loc 属性支持选择单行或多行。
使用 loc 和 iloc 访问数据:
loc 基于标签（index label 和 column name）进行选择。
iloc 基于位置（integer position）进行选择。
切片操作:
loc 和 iloc 都支持切片操作，语法类似于 Python 列表的切片。
loc 的切片包含起始和结束标签，而 Python 列表的切片不包含结束标签。
访问单个值:
at 和 iat 用于快速访问单个值。
at 基于标签，iat 基于位置。

索引方式比较:

loc: 通过标签(label)索引数据, 包含起点和终点
iloc: 通过位置(position)索引数据, 包含起点但不包含终点
at 和 iat: 通过标签或位置直接获取单个元素, 速度更快
Series 对象:
Series 对象也支持 loc, iloc, at, iat 进行数据访问。
Jupyter Notebook 的 %%timeit:
%%timeit 用于测量代码执行时间，可以比较不同方法的效率。

1. 选择列:

nba.Salary: 选择名为 "Salary" 的列，返回一个 Series 对象，包含该列的所有值。
type(nba.Salary): 查看 nba.Salary 的数据类型，结果为 pandas.core.series.Series。
nba['Position']: 选择名为 "Position" 的列，返回一个 Series 对象。
nba[['Salary', 'Birthday']]: 选择 "Salary" 和 "Birthday" 两列，返回一个 DataFrame 对象，包含这两列的所有值。
type(nba[['Salary', 'Birthday']]): 查看 nba[['Salary', 'Birthday']] 的数据类型，结果为 pandas.core.frame.DataFrame。

2. 按数据类型选择列:

nba.dtypes: 查看 DataFrame 中每一列的数据类型。
nba.select_dtypes(include='object'): 选择所有数据类型为 object (字符串) 的列。
nba.select_dtypes(exclude=['object', 'int']): 排除所有数据类型为 object (字符串) 和 int (整数) 的列。

3. 选择行:

nba.loc['LeBron James']: 选择索引标签为 "LeBron James" 的行，返回一个 Series 对象，包含该行所有列的值。
nba.loc[['Kawhi Leonard', 'Paul George']]: 选择索引标签为 "Kawhi Leonard" 和 "Paul George" 的两行，返回一个 DataFrame 对象，包含这两行的所有列的值。
nba.loc[['Paul George', 'Kawhi Leonard']]: 选择索引标签为 "Paul George" 和 "Kawhi Leonard" 的两行，顺序与上面一行不同，但结果相同。

# 类似python list的slice操作
# 先按照 index label 进行排序，以加速查找

# loc的[]和python list的slice的[]的区别
# loc的[]的范围： [a, b]
# python list slice操作的范围: [a, b)

4. 按标签索引:

nba.sort_index().loc['Otto Porter':'Patrick Beverley']: 先对 DataFrame 按索引排序, 然后使用 loc 根据标签范围获取数据
players = ['Otto Porter', 'PJ Dozier', 'PJ Washington']
players[0:2]
nba.loc['Zach Collins':] 和 nba.loc[:'Al Horford']: 分别获取从 'Zach Collins' 到末尾, 和从开头到 'Al Horford' 的数据
nba.loc['Zhang San']: 如果索引标签不存在, 会报错

5.按位置索引:

nba.iloc[300]: 获取第 301 行(索引从 0 开始)的数据
nba.iloc[[100, 200, 300, 400]]: 获取多行数据
nba.iloc[400:404]: 获取 400 到 403 行的数据
nba.iloc[:2]: 获取前 2 行数据
nba.iloc[447:]: 获取从第 448 行到末尾的数据
nba.tail(10): 获取最后 10 行数据
nba.iloc[-10:-6]: 获取倒数第 10 行到倒数第 6 行的数据
nba.iloc[0:10:2]: 以步长为 2 获取 0 到 9 行的数据

6.查询特定行列数据:

nba.loc['LeBron James', 'Team']: 获取 'LeBron James' 所在的球队
nba.loc['James Harden', ['Position', 'Birthday']]: 获取 'James Harden' 的位置和生日
nba.loc[
    ['Russell Westbrook', 'Anthony Davis'],
    ['Team', 'Salary']
]: 获取 'Russell Westbrook' 和 'Anthony Davis' 的球队和工资
nba.loc['Joel Embiid', 'Position':'Salary']: 获取 'Joel Embiid' 从位置到工资的所有属性
nba.loc['Joel Embiid']: 获取 'Joel Embiid' 所有属性
 要注意指定的属性的顺序必须与DataFrame中属性的顺序相一致

nba.loc['Joel Embiid', 'Salary':'Position']
 尝试使用 loc 选择 'Joel Embiid' 这一行的 'Salary' 到 'Position' 的属性，但是由于指定的属性顺序与 DataFrame 中属性的顺序不一致，所以会报错。

nba.columns
 会返回 DataFrame nba 的所有列名，可以用来查看属性的顺序。

nba.iloc[57, 3]
查询row index为57，column index为3（Salary）的值， 使用 iloc 查找 row index 为 57，column index 为 3（对应 'Salary' 属性）的值。



nba.iloc[57]
 使用 iloc 查找 row index 为 57 的整行数据，返回一个 Series 对象。



nba.iloc[100:104, :3]
 查询row index [100, 104), column index[0:3),使用 iloc 查找 row index 从 100 到 103（不包含 104），column index 从 0 到 2（不包含 3）的数据，返回一个 DataFrame 对象。



nba.iloc[100:104]
 使用 iloc 查找 row index 从 100 到 103（不包含 104）的所有列的数据，返回一个 DataFrame 对象。



使用at和iat查询某个单一值,可以更快速地定位数据

nba.at['Austin Rivers', 'Birthday']

 使用 at 查找 'Austin Rivers' 这一行的 'Birthday' 属性的值，返回一个单一值。



nba.iat[263, 1]

 使用 iat 查找 row index 为 263，column index 为 1 的值，返回一个单一值。



 jupyter notebook magic method

 %%timeit

 计算一个cell中代码执行过程的平均耗时

%%timeit

nba.at['Austin Rivers', 'Birthday']

 使用  jupyter notebook 的 magic method %%timeit 来计算 nba.at['Austin Rivers', 'Birthday']  的平均执行时间。



%%timeit

nba.loc['Austin Rivers', 'Birthday']

 使用  jupyter notebook 的 magic method %%timeit 来计算 nba.loc['Austin Rivers', 'Birthday']  的平均执行时间。



 Series也可以使用loc、iloc、at、iat

nba['Salary'].loc['Damian Lillard']

 首先获取  'Salary' 这一列，然后使用 loc 查找 'Damian Lillard' 对应的值。



nba['Salary'].at['Damian Lillard']

 首先获取  'Salary' 这一列，然后使用 at 查找 'Damian Lillard' 对应的值。



nba.Salary.iloc[234]

 使用 iloc 查找 'Salary' 这一列的 row index 为 234 的值。



nba.Salary.iat[234]

 使用 iat 查找 'Salary' 这一列的 row index 为 234 的值。

给行和列重命名

使用 columns 属性访问 DataFrame 的列名，直接赋值给 columns 属性来修改列名。
head(n) 方法返回 DataFrame 的前 n 行，head(0) 返回空 DataFrame。

1. rename() 方法

可以修改列名和索引标签，columns 参数用于指定列名的修改。返回一个新的 DataFrame，需要将其赋值给原变量才能保存修改。 index 参数用于指定索引标签的修改。

loc 基于标签进行数据选择。

2. set_index() 方法

可以将指定的列设置为新的索引标签。

3. reset_index() 方法

可以恢复默认的数字索引。

nba.reset_index().set_index('Team')先恢复默认的数字索引，然后将 'Team' 列设置为新的索引标签，保留原来的索引标签作为一列数据。

nba.columns 返回 DataFrame nba 的所有列名，以 Index 对象的形式。


nba.columns = ['Team', 'Position', 'Date of Birth', 'Pay']直接修改 DataFrame 的列名，将原来的列名替换为新的列表。


nba.head(0)返回一个空的 DataFrame，用于展示修改后的列名。


nba.rename(columns={'Date of Birth':'Birthday'})使用 rename() 方法修改列名，通过字典指定要修改的列名和新的列名。


nba = nba.rename(columns={'Date of Birth':'Birthday'}) 将修改后的 DataFrame 赋值给 nba 变量，保存修改结果。


nba.loc['Giannis Antetokounmpo']
使用 loc 查找索引标签为 'Giannis Antetokounmpo' 的行数据。


nba = nba.rename(index={'Giannis Antetokounmpo':'Greek Freak'}) 使用 rename() 方法修改索引标签，通过字典指定要修改的索引标签和新的索引标签。


nba.loc['Greek Freak']
使用 loc 查找修改后的索引标签 'Greek Freak' 对应的行数据。


nba.head()
返回 DataFrame 的前 5 行，用于展示修改后的索引标签。


nba.set_index(keys='Team')
将 'Team' 列设置为新的索引标签，原来的索引标签会被丢弃。


nba.reset_index()
将索引标签恢复为默认的数字形式，并将原来的索引标签作为一列添加到 DataFrame 中。


nba.reset_index().set_index('Team')先恢复默认的数字索引，然后将 'Team' 列设置为新的索引标签，保留原来的索引标签作为一列数据。

练习题

# 1. 导入nfl.csv，将Birthday转为datetimes
nfl = pd.read_csv('nfl.csv', parse_dates=['Birthday'])
nfl

# 2. 用2种方法将DataFrame的index设置为name
# 第一种方法
nfl = nfl.set_index('Name')
nfl

# 第二种方法
nfl_2 = pd.read_csv('nfl.csv', parse_dates=['Birthday'], index_col='Name')
nfl

# 3. 统计每个队伍的球员数量
nfl['Team'].value_counts()

# 4. 查找工资最高的5个球员
nfl.sort_values(by=['Salary'], ascending=False).head(5)

# 5. 排序
# 先将team按字母顺序排序
# 再将salary按降序排序
nfl.sort_values(by=['Team', 'Salary'], ascending=[True, False])

# 6. New York Jets roster队中年龄最大的球员是谁，他的生日是什么时候
nfl = nfl.reset_index().set_index('Team')
nfl

nfl.loc['New York Jets']

nfl.loc['New York Jets'].sort_values('Birthday').head(1)

练习5

1.info()

功能: info() 函数用于获取 DataFrame 的简要摘要，包括索引信息、数据类型、非空值数量以及内存使用情况。
语法: DataFrame.info()

2.astype()

功能: astype() 函数用于更改 Series 或 DataFrame 中一列或多列的数据类型。
语法: Series.astype(dtype) 或 DataFrame.astype({'column_name': dtype})

3.fillna()

功能: fillna() 函数用于填充 DataFrame 或 Series 中的缺失值（NaN）。

语法:

DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
Series.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)

主要参数:
- value: 用于填充缺失值的标量值、字典、Series 或 DataFrame。
- method: 填充方法，可以是：
  - 'backfill' 或 'bfill': 用后面的值填充缺失值。
  - 'ffill' 或 'pad': 用前面的值填充缺失值。
- axis: 填充的方向，可以是 0（按列填充）或 1（按行填充）。
- inplace: 是否修改原始 DataFrame 或 Series。默认为 False，返回一个新的对象。
- limit: 最大填充数量。

import pandas as pd
import numpy as np

data = {'A': [1, 2, np.nan, 4], 
        'B': [5, np.nan, 7, 8], 
        'C': [9, 10, 11, np.nan]}
df = pd.DataFrame(data)

# 用 0 填充所有缺失值
df.fillna(0)

# 用前面的值填充 'A' 列的缺失值
df['A'].fillna(method='ffill')

# 用后面的值填充 'B' 列的缺失值
df['B'].fillna(method='bfill')

# 按行填充，用字典指定每列的填充值
df.fillna(axis=1, value={'A': 0, 'B': 5, 'C': 10})

fillna() 函数提供了灵活的缺失值填充方式，可以使用固定值、前后的值或其他策略进行填充。
填充方法的选择取决于数据的特点和分析目标。
inplace=True 可以直接修改原始 DataFrame 或 Series，无需创建新的对象。

4.nunique()

功能: nunique() 函数用于计算 DataFrame 或 Series 中的唯一值的数量，忽略缺失值。

语法:

DataFrame.nunique(axis=0, dropna=True)
Series.nunique(dropna=True)

主要参数:
- axis: 计算唯一值的轴，可以是 0（按列计算）或 1（按行计算）。DataFrame 默认值为 0。
- dropna: 是否忽略缺失值。默认为 True，即计算时不包含缺失值。

nunique() 函数可以快速统计唯一值的数量，有助于了解数据的分布情况。
可以通过 axis 参数指定计算方向，适用于不同维度的数据分析。
dropna 参数可以控制是否包含缺失值，根据实际情况进行选择。

5.pandas的数据类型category

功能: category 数据类型是一种用于表示分类变量的特殊数据类型。它将数据存储为整数类别代码，并使用一个映射表将这些代码与实际类别值关联起来。
优点:
- 内存效率: category 数据类型比 object 数据类型更节省内存，尤其是在处理大量重复类别值时。
- 性能提升: 使用 category 数据类型可以加速某些操作，例如分组和排序。
- 数据一致性: category 数据类型可以确保数据的一致性，避免出现拼写错误或大小写不一致等问题。

category 数据类型适用于表示分类变量，可以节省内存、提高性能并确保数据一致性。
可以使用 astype('category') 或 Categorical 构造函数创建 category 数据类型。
category 数据类型提供了多种属性和方法，用于访问和操作类别信息。

6. 单条件过滤

单条件过滤是指根据 DataFrame 中某一列的值满足特定条件来选择数据。

操作符

==: 等于
!=: 不等于
> : 大于
< : 小于
>=: 大于等于
<=: 小于等于

1.布尔索引:

创建一个布尔 Series，该 Series 表示 DataFrame 中每一行是否满足条件。使用这个布尔 Series 作为 DataFrame 的索引来选择满足条件的行。

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 20, 28],
        'City': ['New York', 'London', 'Paris', 'Tokyo']}
df = pd.DataFrame(data)

# 选择年龄大于 25 岁的行
df[df['Age'] > 25]

2. `query` 方法:

你使用类似 SQL 的语法进行过滤。对于单条件过滤，这可能比布尔索引更易读。

# 选择年龄大于 25 岁的行
df.query('Age > 25')

3. `isin` 方法:

选择某一列的值存在于给定列表中的行，使用 isin 方法。

# 选择住在 New York 的行
df[df['City'].isin(['New York'])]

4. `loc` 属性:

使用 loc 属性根据标签进行过滤。例如，要选择 'Age' 列大于 25 的行，你可以使用：

df.loc[df['Age'] > 25]

单条件过滤可以使用布尔索引或 query() 方法。
布尔索引使用布尔表达式，query() 方法使用字符串表达式。
可以使用各种操作符进行比较，例如 ==, !=, >, <, >=, <=。
可以使用字符串方法进行更复杂的过滤，例如 startswith(), endswith(), contains() 等。

7.多条件过滤

使用逻辑运算符 (& for AND, | for OR, ~ for NOT) 组合多个布尔条件。

# 选择年龄大于 25 岁且住在 London 的
df[(df['Age'] > 25) & (df['City'] == 'London')]

8.isin（）

用于检查 DataFrame 的某一列或 Series 的值是否存在于给定列表、集合或其他可迭代对象中。它返回一个布尔 Series，表示每个元素是否包含在给定值中。

语法：

Series.isin(values)
DataFrame['column'].isin(values)

参数：

values: 可迭代对象，包含需要检查的值。可以是列表、集合、元组、Series 等。

返回值：

布尔 Series，与调用 isin() 的 Series 或 DataFrame 列具有相同的长度。如果对应位置的值存在于 values 中，则该位置的值为 True，否则为 False。

示例：

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 20, 28],
        'City': ['New York', 'London', 'Paris', 'Tokyo']}
df = pd.DataFrame(data)

# 检查 'City' 列中哪些城市属于 ['New York', 'Paris']
result = df['City'].isin(['New York', 'Paris'])
print(result)

输出：

0     True
1    False
2     True
3    False
Name: City, dtype: bool

应用：

数据过滤: 结合布尔索引，筛选出包含特定值的行。
数据清洗: 识别并处理异常值或不符合预期格式的数据。
数据分组: 根据 isin() 返回的布尔 Series 将数据分组进行分析。

注意：

isin() 方法对大小写敏感。
values 参数可以是任何可迭代对象，但通常使用列表或集合。

9.isnull（）和notnull（）

isnull() 函数返回一个布尔数组，指示 DataFrame 或 Series 中每个元素是否为缺失值。如果元素是缺失值，则返回 True，否则返回 False。

notnull() 函数与 isnull() 函数相反，它返回一个布尔数组，指示 DataFrame 或 Series 中每个元素是否不是缺失值。如果元素不是缺失值，则返回 True，否则返回 False。

语法：

Series.isnull()
DataFrame.isnull()

Series.notnull()
DataFrame.notnull()

isnull() 用于检测缺失值，返回 True 表示缺失值。
notnull() 用于检测非缺失值，返回 True 表示非缺失值。

10.dropna（）

dropna() 函数用于删除 DataFrame 或 Series 中包含缺失值 (NaN) 的行或列。

语法：

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

参数：

axis: 指定删除行还是列。
- 0 或 'index': 删除包含缺失值的行。
- 1 或 'columns': 删除包含缺失值的列。
how: 指定删除条件。
- 'any': 只要该行/列包含至少一个缺失值，就删除该行/列。
- 'all': 只有当该行/列的所有元素都是缺失值时，才删除该行/列。
thresh: 指定非缺失值数量的阈值。如果该行/列中非缺失值的數量小于阈值，则删除该行/列。
subset: 指定要检查缺失值的列的列表。仅在 axis=0 时有效。
inplace: 指定是否修改原始 DataFrame 或 Series。
- True: 直接修改原始 DataFrame 或 Series。
- False: 返回一个新的 DataFrame 或 Series，原始数据不变。

1.删除所有元素都是缺失值的列:

df.dropna(axis=1, how='all', inplace=True)

2.删除 'Age' 列中包含缺失值的行:

df.dropna(subset=['Age'], inplace=True)

3.删除非缺失值少于 2 个的行:

df.dropna(thresh=2, inplace=True)

默认情况下，dropna() 函数会返回一个新的 DataFrame 或 Series，原始数据不会被修改。如果要直接修改原始数据设置 inplace=True。
dropna() 函数不会修改 DataFrame 或 Series 的索引。如果需要重置索引，可以使用 reset_index() 函数。

11.duplicated()处理重复值

duplicated() 函数用于识别 DataFrame 中的重复行。它返回一个布尔 Series，指示每行是否是重复行。

语法：

DataFrame.duplicated(subset=None, keep='first')

参数：

subset: 指定用于检查重复值的列的列表。如果为 None，则使用所有列。
keep: 指定如何标记重复值。
- 'first': 标记除第一次出现的重复行之外的所有重复行为 True。
- 'last': 标记除最后一次出现的重复行之外的所有重复行为 True。
- False: 标记所有重复行为 True。

返回值：

布尔 Series，指示每行是否是重复行。

示例：

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
        'Age': [25, 30, 20, 25, 30],
        'City': ['New York', 'London', 'Paris', 'New York', 'London']}
df = pd.DataFrame(data)

# 识别所有重复行
duplicates = df.duplicated()
print(duplicates)

输出：

0    False
1    False
2    False
3     True
4     True
dtype: bool

应用：

识别重复行: 使用 duplicated() 函数可以轻松识别 DataFrame 中的重复行。
删除重复行: 可以使用布尔索引或 drop_duplicates() 函数删除重复行。

1. 使用布尔索引删除重复行:

df = df[~duplicates]
print(df)

2. 使用 `drop_duplicates()` 函数删除重复行:

df.drop_duplicates(inplace=True)
print(df)

注意：

duplicated() 函数默认情况下保留第一次出现的重复行，并标记其他重复行为 True。可以使用 keep 参数更改此行为。
drop_duplicates() 函数默认情况下保留第一次出现的重复行，并删除其他重复行。可以使用 keep 参数更改此行为。

练习题

优化数据集以限制内存使用并最大化效用。 这可能包括选择合适的数据类型、删除不必要的列等操作。
找到所有标题为 "Limitless" 的行。
找到所有导演为 "Robert Rodriguez" 且类型为 "Movie" 的行。
找到所有添加日期为 "2019-07-31" 或导演为 "Robert Altman" 的行。
找到所有导演为 "Orson Welles"、"Aditya Kripalani" 或 "Sam Raimi" 的行。
找到所有添加日期在 2019 年 5 月 1 日至 2019 年 6 月 1 日之间的行。
删除导演列中包含 NaN 值的所有行。
确定 Netflix 只在其目录中添加了一部电影的日期。

# 优化数据集以限制内存使用并最大化效用
netflix = pd.read_csv('netflix.csv', parse_dates=['date_added'])
netflix.info()
netflix.nunique()

netflix['type'] = netflix['type'].astype('category')
netflix.info()

# 找到所有标题为 "Limitless" 的行。
title = netflix['title'] == 'Limitless'
netflix[title]


# 找到所有导演为 "Robert Rodriguez" 且类型为 "Movie" 的行。
director = (netflix['director'] == 'Robert Rodriguez')
typeMovie = netflix['type'] == 'Movie'
netflix[director & typeMovie]
# 找到所有添加日期为 "2019-07-31" 或导演为 "Robert Altman" 的行。
date = netflix['date_added'] == '2019-07-31'
director = netflix['director'] == 'Robert Altman'
netflix[date | director]

# 找到所有导演为 "Orson Welles"、"Aditya Kripalani" 或 "Sam Raimi" 的行
directors = ['Orson Welles', 'Aditya Kripalani', 'Sam Raimi']
target = netflix['director'].isin(directors)
netflix[target]

# 找到所有添加日期在 2019 年 5 月 1 日至 2019 年 6 月 1 日之间的行。
addMovie = netflix['date_added'].between('2019-5-1', '2019-6-1')
netflix[addMovie]


# 删除导演列中包含 NaN 值的所有行。
netflix.dropna(subset = ['director'])


# 确定 Netflix 只在其目录中添加了一部电影的日期。
netflix.drop_duplicates(subset=['date_added'], keep=False)