用pandas探索你的数据（一）开始了解你的数据

用pandas探索你的数据（一）：开始了解你的数据

探索Chipotle快餐数据

步骤1 导入必要的库

# 运行以下代码
import pandas as pd

步骤2 从如下地址导入数据集

# 运行以下代码
path1 = "exercise_data/chipotle.tsv"    # chipotle.tsv

步骤3 将数据集存入一个名为chipo的数据框内

pandas 中的 read_csv 函数用于从 CSV（逗号分隔值）文件中读取数据并将其转换为 DataFrame（数据表格）。下面是有关 read_csv 函数的详细解释：

pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, dtype=None, parse_dates=False, na_values=None, thousands=None, decimal='.', keep_default_na=True, skipinitialspace=False, skiprows=None, skipfooter=0, encoding=None, engine='c', comment=None, quoting=None, doublequote=True, quotechar='"', escapechar=None, nrows=None, dayfirst=False, date_parser=None, memory_map=False, float_precision=None, storage_options=None)

常用参数的解释：

1. filepath_or_buffer：必选参数，指定要读取的 CSV 文件的路径或 URL，也可以是一个类文件对象（如 StringIO 或 BytesIO）。
2. sep：可选参数，默认为逗号（','），用于指定字段之间的分隔符，例如 '\t' 表示制表符分隔。
3. delimiter：可选参数，与 sep 具有相同的作用，用于指定分隔符。
4. header：可选参数，默认为 'infer'，用于指定哪一行作为列名，如果设置为 None，则不使用列名。
5. names：可选参数，用于手动指定列名，可以传入一个列表，与 CSV 文件的列数对应。
6. index_col：可选参数，用于指定哪一列作为索引列，可以是列名或列的索引（0 表示第一列，1 表示第二列，以此类推）。
7. usecols：可选参数，用于指定要读取的列，可以是列名或列的索引，传入一个列表。
8. dtype：可选参数，用于指定每列的数据类型，可以传入一个字典，将列名映射到数据类型。
9. parse_dates：可选参数，用于指定是否尝试解析日期列，可以传入列名或列的索引，或一个包含列名/索引的列表。
10. na_values：可选参数，用于指定将被解释为缺失值的值，例如 'NA'、'NaN' 等。
11. thousands：可选参数，用于指定千位分隔符，例如 ','。
12. decimal：可选参数，用于指定小数点符号。
13. skiprows：可选参数，用于指定要跳过的行数，可以传入一个整数或包含要跳过的行索引的列表。
14. encoding：可选参数，用于指定文件的编码格式，例如 'utf-8'、'latin1' 等。
15. engine：可选参数，用于指定解析引擎，通常不需要手动指定，'c' 通常是最快的。
16. comment：可选参数，用于指定注释符号，解析时会忽略注释符号后面的内容。
17. quoting：可选参数，用于指定引用字段的引号规则，例如 'minimal'、'all' 等。
18. nrows：可选参数，用于指定要读取的行数，从文件的开头开始读取。
19. date_parser：可选参数，用于指定一个自定义日期解析函数。
20. float_precision：可选参数，用于指定浮点数的精度。
21. storage_options：可选参数，用于传递给底层存储库的选项，如 Amazon S3。

# 运行以下代码
chipo = pd.read_csv(path1, sep = '\t')

步骤4 查看前10行内容

pandas 中的 head 和 tail 函数用于查看 DataFrame 的前几行和后几行数据，以便快速浏览数据的开头和结尾。下面是关于这两个函数的详细解释：

1. head 函数：

DataFrame.head(n=5)

head 函数默认返回 DataFrame 的前5行数据，但您可以通过传递 n 参数来指定要返回的行数。例如，DataFrame.head(10) 将返回前10行数据。

2. tail 函数：

DataFrame.tail(n=5)

tail 函数默认返回 DataFrame 的最后5行数据，但您也可以通过传递 n 参数来指定要返回的行数。例如，DataFrame.tail(8) 将返回最后8行数据。

这两个函数的主要用途是在处理大型数据集时，快速查看数据的一部分，以了解数据的结构和内容，以及检查数据是否被正确加载。它们不会修改原始数据，而只是返回一个新的 DataFrame，包含所请求的行数。

示例用法：

import pandas as pd

# 创建一个示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
        'Age': [25, 30, 35, 40, 45]}
df = pd.DataFrame(data)

# 使用 head 查看前两行数据
print(df.head(2))

# 使用 tail 查看最后三行数据
print(df.tail(3))

这将输出：

      Name  Age
0    Alice   25
1      Bob   30

      Name  Age
2  Charlie   35
3    David   40
4      Eve   45

# 运行以下代码
chipo.head(10)

<div>
<style scoped>

.dataframe tbody tr th:only-of-type {
    vertical-align: middle;
}

.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}

</style>

	order_id	quantity	item_name	choice_description	item_price
0	1	1	Chips and Fresh Tomato Salsa	NaN	$2.39
1	1	1	Izze	[Clementine]	$3.39
2	1	1	Nantucket Nectar	[Apple]	$3.39
3	1	1	Chips and Tomatillo-Green Chili Salsa	NaN	$2.39
4	2	2	Chicken Bowl	[Tomatillo-Red Chili Salsa (Hot), [Black Beans...	$16.98
5	3	1	Chicken Bowl	[Fresh Tomato Salsa (Mild), [Rice, Cheese, Sou...	$10.98
6	3	1	Side of Chips	NaN	$1.69
7	4	1	Steak Burrito	[Tomatillo Red Chili Salsa, [Fajita Vegetables...	$11.75
8	4	1	Steak Soft Tacos	[Tomatillo Green Chili Salsa, [Pinto Beans, Ch...	$9.25
9	5	1	Steak Burrito	[Fresh Tomato Salsa, [Rice, Black Beans, Pinto...	$9.25

</div>

步骤6 数据集中有多少个列(columns)

pandas 中的 shape 属性是 DataFrame 和 Series 对象的一个属性，它用于获取数据结构的维度信息。具体来说，shape 返回一个元组，表示 DataFrame 或 Series 的维度，其中第一个元素是行数，第二个元素是列数。

对于 DataFrame，shape 属性返回一个表示行数和列数的元组 (行数, 列数)。对于 Series，shape 属性返回一个包含单一元素的元组，即 (元素数量,)，因为 Series 只有一列。

# 运行以下代码
chipo.shape[1]

5

# 查看有多少行
chipo.shape[0]

4622

步骤7 打印出全部的列名称

# 运行以下代码
chipo.columns

Index(['order_id', 'quantity', 'item_name', 'choice_description',
       'item_price'],
      dtype='object')

步骤8 数据集的索引是怎样的

# 运行以下代码
chipo.index

RangeIndex(start=0, stop=4622, step=1)

步骤9 被下单数最多商品(item)是什么?

1. grouby函数

pandas 中的 groupby 函数用于将数据按照某一列或多列的值进行分组，然后可以对这些分组进行聚合操作，如求和、计数、平均值等。这是进行数据分析和数据透视的重要操作之一。以下是 groupby 函数的详细解释和用法：

DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

主要参数：

• by：分组依据，可以是列名、列名的列表、字典、函数或多个列名。这是 groupby 最重要的参数，用于指定如何分组数据。
• axis：默认为0，指定按行（0）或按列（1）进行分组。
• level：如果 DataFrame 包含多级索引，可以指定要按哪一级进行分组。
• as_index：默认为 True，如果设置为 True，分组的键将成为结果 DataFrame 的索引，否则会作为列添加到结果 DataFrame。
• sort：默认为 True，如果设置为 False，可以提高性能，但结果可能不会按照分组键排序。
• group_keys：默认为 True，如果设置为 False，则不在结果 DataFrame 中包含分组键。
• squeeze：默认为 False，如果为 True 并且只有一组数据，则返回一个 Series。
• observed：默认为 False，如果设置为 True，则在多级索引情况下，只使用观察到的值进行分组。
• agg函数

agg 函数（短 for "aggregate"）是 pandas 中用于对 DataFrame 或 Series 执行多个聚合操作的灵活工具。agg 函数允许您一次性传递多个聚合函数，并在每个聚合函数上对数据进行操作。以下是 agg 函数的详细解释和用法：

DataFrame.agg(func, axis=0, *args, **kwargs)

主要参数：

• func：一个函数、函数列表、函数字典或函数字符串，用于指定要应用于数据的聚合操作。这可以是单个聚合函数或多个聚合函数的组合。
• axis：默认为0，指定应用聚合操作的轴，0 表示按列应用，1 表示按行应用。
• *args 和 **kwargs：可选参数，用于传递给聚合函数的额外参数。

# 运行以下代码，做了修正
c = chipo[['item_name','quantity']].groupby(['item_name'],as_index=False).agg({'quantity':sum})
c.sort_values(['quantity'],ascending=False,inplace=True)
c.head()

<div>
<style scoped>

.dataframe tbody tr th:only-of-type {
    vertical-align: middle;
}

.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}

</style>

	item_name	quantity
17	Chicken Bowl	761
18	Chicken Burrito	591
25	Chips and Guacamole	506
39	Steak Burrito	386
10	Canned Soft Drink	351

</div>

(chipo[['item_name', 'quantity']].groupby(['item_name'], as_index=False).agg({'quantity':'sum'})
.sort_values(['quantity'], ascending=False, inplace=False)
.head(10))

<div>
<style scoped>

.dataframe tbody tr th:only-of-type {
    vertical-align: middle;
}

.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}

</style>

	item_name	quantity
17	Chicken Bowl	761
18	Chicken Burrito	591
25	Chips and Guacamole	506
39	Steak Burrito	386
10	Canned Soft Drink	351
23	Chips	230
38	Steak Bowl	221
6	Bottled Water	211
24	Chips and Fresh Tomato Salsa	130
9	Canned Soda	126

</div>

步骤10 在item_name这一列中，一共有多少种商品被下单？

nunique 函数是 pandas 中用于计算 DataFrame 或 Series 中唯一值的数量的函数。nunique 是 "number of unique" 的缩写，它返回一个标量值，表示唯一值的数量。以下是 nunique 函数的详细解释和用法：

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

主要参数：

• axis：默认为 0，用于指定计算唯一值数量的轴，0 表示按列计算，1 表示按行计算。
• dropna：默认为 True，如果设置为 True，将忽略缺失值（NaN），只计算非缺失值的唯一值数量。

以下是一些示例用法：

1. 对 Series 使用 nunique：

import pandas as pd

data = pd.Series([1, 2, 2, 3, 4, 4, 4, 5, 5, None])

# 计算 Series 中的唯一值数量
unique_count = data.nunique()
print(unique_count)

输出：

5

在这个示例中，nunique 函数计算了 Series 中的唯一值数量，忽略了缺失值（None），因此返回了5。

2. 对 DataFrame 使用 nunique：

data = {'A': [1, 2, 2, 3, 4, 4],
        'B': [4, 5, 5, 6, None, 6]}

df = pd.DataFrame(data)

# 计算 DataFrame 中每列的唯一值数量
unique_counts = df.nunique()
print(unique_counts)

输出：

A    4
B    4
dtype: int64

在这个示例中，nunique 函数对 DataFrame 中的每列计算了唯一值的数量，分别是列 'A' 中的4个唯一值和列 'B' 中的4个唯一值。

nunique 函数在数据清理、探索性数据分析以及数据统计中经常被用到，它可以帮助您了解数据中不同值的多样性程度。通过设置 axis 参数，您可以在不同的维度上计算唯一值的数量，从而更好地理解数据的特点。

# 运行以下代码
chipo['item_name'].nunique()

50

步骤11 在choice_description中，下单次数最多的商品是什么？

chipo['choice_description'].value_counts().head()

choice_description
[Diet Coke]                                                                          134
[Coke]                                                                               123
[Sprite]                                                                              77
[Fresh Tomato Salsa, [Rice, Black Beans, Cheese, Sour Cream, Lettuce]]                42
[Fresh Tomato Salsa, [Rice, Black Beans, Cheese, Sour Cream, Guacamole, Lettuce]]     40
Name: count, dtype: int64

value_counts 函数是 pandas 中用于计算 Series 或 DataFrame 中唯一值的频次（出现次数）的函数。value_counts 返回一个包含唯一值及其对应频次的 Series，唯一值作为索引，频次作为值。以下是 value_counts 函数的详细解释和用法：

Series.value_counts(normalize=False, sort=True, ascending=False, dropna=True)

主要参数：

• normalize：默认为 False，如果设置为 True，返回的结果将是频次的相对比例而不是绝对频次。
• sort：默认为 True，如果设置为 False，结果将按照唯一值的顺序而不是频次降序排序。
• ascending：默认为 False，如果设置为 True，结果将按照频次升序排序。
• dropna：默认为 True，如果设置为 False，将包括缺失值（NaN）在内的所有值的频次。

以下是一些示例用法：

1. 对 Series 使用 value_counts：

import pandas as pd

data = pd.Series([1, 2, 2, 3, 3, 3, 4, 4, None, None])

# 计算 Series 中各个值的频次
value_counts = data.value_counts()
print(value_counts)

输出：

3.0    3
2.0    2
4.0    2
1.0    1
dtype: int64

在这个示例中，value_counts 函数计算了 Series 中各个值的频次，忽略了缺失值（None）。

2. 使用 normalize 参数获取相对频次：

# 计算 Series 中各个值的相对频次
relative_frequency = data.value_counts(normalize=True)
print(relative_frequency)

输出：

3.0    0.375
2.0    0.250
4.0    0.250
1.0    0.125
dtype: float64

在这个示例中，通过将 normalize 参数设置为 True，value_counts 返回了各个值的相对频次（频次的比例）。

value_counts 函数常用于数据探索性分析，可以帮助您了解数据中不同值的分布情况，识别常见值，检查异常值等。

步骤12 一共有多少商品被下单？

# 运行以下代码
total_items_orders = chipo['quantity'].sum()
total_items_orders

4972

步骤13 将item_price转换为浮点数

# 运行以下代码
dollarizer = lambda x: float(x[1:-1])
chipo['item_price'] = chipo['item_price'].apply(dollarizer)

apply 函数是 pandas 中的一个强大工具，用于在 DataFrame 或 Series 上应用自定义函数或内置函数，以进行元素级的操作和转换。apply 函数可以对每个元素、每列或每行数据执行指定的函数，并将结果整合成新的 Series 或 DataFrame。以下是 apply 函数的详细解释和用法：

DataFrame/Series.apply(func, axis=0, raw=False, result_type=None, args=(), **kwds)

主要参数：

• func：要应用的函数，可以是自定义函数或内置函数。
• axis：默认为 0，用于指定函数的应用方向。0 表示按列应用函数，1 表示按行应用函数。
• raw：默认为 False，如果设置为 True，则将传递原始 NumPy 数组给函数，否则传递 Series 或 DataFrame。
• result_type：可选参数，指定结果的数据类型，可以是 'expand'（默认）、'reduce' 或 'broadcast'。
• args 和 **kwds：可选参数，用于传递给函数的额外参数。

以下是一些示例用法：

1. 对 Series 使用 apply：

import pandas as pd

data = pd.Series([1, 2, 3, 4, 5])

# 定义一个自定义函数，将元素加倍
def double(x):
    return x * 2

# 使用 apply 应用自定义函数
result = data.apply(double)
print(result)

输出：

0     2
1     4
2     6
3     8
4    10
dtype: int64

在这个示例中，我们定义了一个自定义函数 double，然后使用 apply 将该函数应用于 Series 中的每个元素，将每个元素加倍。

2. 对 DataFrame 使用 apply：

data = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# 定义一个自定义函数，将每列的平均值乘以 2
def double_mean(column):
    return column.mean() * 2

# 使用 apply 应用自定义函数，按列应用
result = data.apply(double_mean)
print(result)

输出：

A    6.0
B    9.0
dtype: float64

在这个示例中，我们定义了一个自定义函数 double_mean，然后使用 apply 将该函数按列应用于 DataFrame，计算每列的平均值并将结果乘以 2。

apply 函数非常灵活，可以用于各种数据转换和操作，包括数据清理、特征工程和数据分析。

步骤14 在该数据集对应的时期内，收入(revenue)是多少

# 运行以下代码,已经做更正
chipo['sub_total'] = round(chipo['item_price'] * chipo['quantity'],2)
chipo['sub_total'].sum()

39237.02

步骤15 在该数据集对应的时期内，一共有多少订单？

# 运行以下代码
chipo['order_id'].nunique()

1834

步骤16 每一单(order)对应的平均总价是多少？

# 运行以下代码，已经做过更正
chipo[['order_id','sub_total']].groupby(by=['order_id']
).agg({'sub_total':'sum'})['sub_total'].mean()

21.39423118865867

步骤17 一共有多少种不同的商品被售出？

# 运行以下代码
chipo['item_name'].nunique()

50

本文由mdnice多平台发布