熊猫查询类似 SQL 的查询
使用 pandas 查询函数查询数据帧的数据科学家 python 教程
目录
- 资料组
- 熊猫
- 询问
- 教程代码
- 摘要
- 参考
资料组
本分析和 pandas 查询教程中使用的数据集是一个虚拟数据集，创建该数据集是为了模拟具有文本和数字特征的数据帧。请随意使用您自己的。csv 文件，包含文本和/或数字列，以遵循教程。
熊猫
Pandas【2】是数据科学家和机器学习工程师最常用的库之一。它主要用于构建模型的探索性数据分析步骤，以及模型结果的即席分析。它还包含几个功能，包括查询功能。
询问
pandas 中的查询函数是一个有用的函数，它的作用类似于 SQL 中的*‘where’*子句。然而，它的好处是，你不需要不断地从 pandas、Jupyter Notebook 和你目前使用的 SQL 平台切换。下面列出了其他一些好处:
- 编译几个条件
- 一个简单的函数，可以处理你的熊猫数据帧
- 引用描述性统计数据，而不是必须进行子查询
教程代码
我已经编写了几个如何使用 pandas 查询功能的例子。下面的屏幕截图总结了一些有用的查询示例。下面，您可以看到如何同时满足文本和数字条件。查找特定列包含特定文本值的行，或者使用 ‘@’ 符号创建描述性统计。例如， ‘@mean_of_column’ 引用了您使用*建立的值。函数均值()'。在第 65 行，返回的行具有一个‘蓝色’值和一个‘已确认 _ 恢复’值，该值大于‘已确认 _ 恢复’本身的平均值，同时还包括‘标签 _ 3’*值。
返回相等的行以及其他几个条件的示例。作者截图[3]。
灰色框中引用的教程代码是用于演示查询函数的所有代码。首先，我进口了熊猫并读取了我的数据帧。然后，我添加新的行，我知道这些行将满足某些条件，以显示如何使用查询函数。*‘append’*函数在这里也很有用，因为它可以快速地向数据帧中添加新行，而不必显式地以序列格式调用每一列。我返回了 ‘df.tail()’ ,以查看返回的行是否是我所期望的。
然后，我返回一列中的值等于另一列中的值的行。您也可以使用相同的逻辑，但是反过来看看您指定的列的哪些值不相等。接下来，您可以比较一列的值是否大于另一列的值，反之亦然。
我认为，query 最有用的特性是 ‘@’ 方法。就像 SQL 中可以使用子查询来引用选择满足特定条件的行一样，这个方法也可以。 ‘@’ 方法保存您想要比较的值。对于下面的例子，我查看了一列的平均值进行比较。
最后，通过输入类似于 SQL 中的和的 ’ & ’ ，可以使用查询函数在一行代码中执行多个条件。
# All the python code below for use:# import libraryimport pandas as pd # read in your dataframedf = pd.read_csv('/Users/example.csv')# write out new rowsrows = [pd.Series([100, 100, 20,'Blue','Label_1'], index=df.columns),pd.Series([100, 80, 60,'Blue','Label_1'], index=df.columns),pd.Series([80, 60, 100,'Blue','Label_1'], index=df.columns)]# append the multiple rowsnew_df = df.append(rows , ignore_index=True)# check the newest 3 rows you madenew_df.tail(3)# return rows where values from one column equal that of another# they do not for this comparisonnew_df.query('Confirmed_Test == Confirmed_New')# return rows where values from one column equal that of another# they do for this comparisonnew_df.query('Confirmed_Test == Confirmed_Recovery')# return rows where values from one column do not equal that of another# they do for this comparisonnew_df.query('Confirmed_New != Confirmed_Recovery').head()# return rows where values from one column are bigger than that of anothernew_df.query('Confirmed_New > Confirmed_Recovery').head()# see which rows where the 'Confirmed_New' values# are greater than the mean of the total column# use the '@' to reference 'cn_mean'cn_mean = new_df['Confirmed_New'].mean()new_df.query('Confirmed_New > @cn_mean').head()# multiple conditions examplecn_min = new_df['Confirmed_New'].min()cn_max = new_df['Confirmed_New'].max()new_df.query('Confirmed_New > @cn_min & Confirmed_New < @cn_max').head()# text conditions# use double quotes for matching on the string value# all the rows returned have 'Blue' for the 'Text_Feature' columnnew_df.query('Text_Feature == "Blue"').head()# return rows which have a 'Blue' value, and a 'Confirmed_Recovery' that is greater# than the mean of 'Confirmed_Recovery' itself, while also satisfying the 'Label_3' value# only 3 return here (did not print out head())cr_mean = new_df['Confirmed_Recovery'].mean()new_df.query('Text_Feature == "Blue" & Confirmed_Recovery > @cr_mean & Text_Predictor == "Label_3"')
要查看 python 格式的代码而不是写出的代码，下面是嵌入的要点【4】:
摘要
pandas 的查询功能是操作数据框架的一种简单快捷的方式。您可以使用类似 SQL 的子句返回满足您确定的条件的某些行。这是有益的，如果你已经在你的 Jupyter 笔记本。ipynb 文件或。py 文件，而不必在 SQL 平台上重新上传或执行 SQL 命令。熊猫查询也很直观，不需要很长时间就能学会。我希望本文中的例子对您有用。感谢您的阅读！
参考
[2]熊猫，熊猫 (2020)
[3] M.Przybyla，截图(2020 年)
[4] M.Przybyla，要点 (2020)
Pandas 查询方法节省了对变量的双重处理
最后更新时间:2020 年 1 月
使用。query()可以使我们在选择数据时不必在一行代码中多次键入数据帧的变量名。
在 pandas DataFrame 对象中检索具有特定条件的行的标准方法需要“双重处理”；不是特别优雅。
例如，我们想要检索列 A 大于 1 的行，这是使用的标准方法。loc 属性。
*## Setup ##**# Import pandas* **import** pandas **as** pd*# Create dataframe from dict* # Specify the type in the suffix of each column name
my_df = pd.DataFrame({**"A_int"**: [1, 2, -3],
**"B_float"**: [7.5, 1.9, 8.4],
**"C_str"**: [**'eight'**, **'nine'**, **'Ten'**],
**"D_str"**: [**'Mar 2017'**, **'May 2018'**, **'Jun 2016'**]}
)*# Convert to datetime column* my_df[**'D_date'**] = pd.to_datetime(my_df[**'D_str'**])"""
>>> my_df
A_int B_float C_str D_str D_date
0 1 7.5 eight Mar 2017 2017-03-01
1 2 1.9 nine May 2018 2018-05-01
2 -3 8.4 Ten Jun 2016 2016-06-01
"""## Show loc example 1 ##ex_1_loc = my_df.loc[my_df[**'A_int'**] > 0, :]"""
>>> ex_1_loc
A_int B_float C_str D_str D_date
0 1 7.5 eight Mar 2017 2017-03-01
1 2 1.9 nine May 2018 2018-05-01
"""
这里，我们获得了布尔行序列，其中对于给定的行，A 列大于 0。。loc 用于取出设置为 True 的行。注意，变量 my_df 在一行代码中使用了两次。
幸好这个变量名不是很长。我发现这种对变量的“双重处理”在语法上类似于 R 中的基本方法，特别是在嵌套和完全不必要的时候。
一些其他语言可以以更易读的格式执行这种过滤:
## SQL EXAMPLE ##
SELECT *
FROM my_df
WHERE A > 0## R-TIDYVERSE EXAMPLE ##
library(tidyverse)
my_df %>%
dplyr::filter(A > 0)
对于 python，我们可以用 pandas 的“查询”方法更简单地做到这一点(类似于上面的 SQL / R-Tidyverse 结构)。查询只返回符合给定条件的行，所有列都保留在数据帧中。
#ex_1_loc = my_df.loc[my_df[**'A_int'**] > 0, :]
ex_1_query = my_df.query("A > 0")
# Or use @ when referencing a variable
pivot_val = 0
ex_1a_query = my_df.query("A > @pivot_val")
标准的熊猫方法经常会让我们看到双重图像 src:https://pix abay . com/photos/panda-family-pandas-cute-bamboo-3811734/
让我们再看六个例子，在这些例子中，query 是对的适当替代。锁定方法
2.对外部列表进行筛选
给定一个外部列表，获取数据帧中某一列与该列表中的一个元素匹配的行
*# Create a list of legitimate entries* legit_entries = [**'eight'**, **'nine'**, **'ten'**]*# Filter column 'C_str' by the array* ex_2_loc = my_df.loc[my_df[**'C_str'**].isin(legit_entries), :]
ex_2_query = my_df.query(**"C_str in @legit_entries"**)"""
A_int B_float C_str D_str D_date
0 1 7.5 eight Mar 2017 2017-03-01
1 2 1.9 nine May 2018 2018-05-01
"""
3.列比较
比较两列—这需要在中进行三重处理。锁定示例。
*# Return rows where 'A_int' is greater than 'B_float'* ex_3_loc = my_df.loc[my_df[**'A_int'**] > my_df[**'B_float'**], :]
ex_3_query = my_df.query(**"A_int > B_float"**)"""
A_int B_float C_str D_str D_date
1 2 1.9 nine May 2018 2018-05-01
"""
4.多条件过滤
在可能的多个列上使用多个条件进行筛选。 & 和 | 位运算符都是允许的。
*# Return rows where 'A_int' is greater than zero
# And where C_str is in the legit_entries array* ex_4_loc = my_df.loc[(my_df[**"A_int"**] > 0) &
(my_df[**'C_str'**].isin(legit_entries)), :]
ex_4_query = my_df.query(**"A_int > 0 & C_str in @legit_entries"**)"""
A_int B_float C_str D_str D_date
0 1 7.5 eight Mar 2017 2017-03-01
1 2 1.9 nine May 2018 2018-05-01
"""
5.时间戳
查询识别日期，并可以将它们与字符串进行比较。查询引号内的所有字符串都必须用引号括起来。
*# Return rows where D_date is after Jan 2018* ex_5_loc = my_df.loc[my_df[**'D_date'**] > **'Jan 2018'**, :]
ex_5_query = my_df.query(**"D_date > 'Jan 2018'"**)"""
A_int B_float C_str D_str D_date
1 2 1.9 nine May 2018 2018-05-01
"""
6.比较前的列转换
您可以在比较之前对给定的列执行函数。
注意 dataframe 的输出仍然包含原来格式的 C_str 列？
*# First convert C_str to lowercase, than compare entries* ex_6_loc = my_df.loc[my_df[**'C_str'**].str.lower().isin(legit_entries),
:]
ex_6_query = my_df.query(**"C_str.str.lower() in @legit_entries"**)"""
A_int B_float C_str D_str D_date
0 1 7.5 eight Mar 2017 2017-03-01
1 2 1.9 nine May 2018 2018-05-01
2 -3 8.4 Ten Jun 2016 2016-06-01
"""
7。包含空格
的列名最初禁止使用 pandas 查询，这个问题在 0.25.2 中已经解决。
用反斜杠引用该列。列中的其他特殊字符可能不起作用。
*# Return rows where 'E rogue column str' column contains the word 'this'* my_df[**'E rogue_column_str'**] = [**'this'**, **'and'**, **'that'**]"""
>>>my_df
A_int B_float C_str D_str D_date E rogue_column_str
0 1 7.5 eight Mar 2017 2017-03-01 this
1 2 1.9 nine May 2018 2018-05-01 and
2 -3 8.4 Ten Jun 2016 2016-06-01 that
"""ex_7_loc = my_df.loc[my_df[**"E rogue_column_str"**] == **'this'**, :]
ex_7_query = my_df.query(**"`E rogue_column_str` == 'this'"**))"""
A_int B_float C_str D_str D_date E rogue_column_str
0 1 7.5 eight Mar 2017 2017-03-01 this
"""
克服“项目”贬值
在熊猫的最新版本(在撰写本文时为 0.25.3)中，。item() 方法已被弃用。结合查询功能， item 是一个非常有用的工具，可以在假设只返回一行的情况下从给定的列中获取单个值。这将把列从类型 pd 转换成。系列的数据类型，如 int、str、float 等。如果返回多行，方法将引发 ValueError。
我们可以使用 squeeze 方法作为替代方法，只需对代码做一些小的修改。与 item 类似，当筛选后的系列只有一行长时，squeeze 会将 pandas 系列从系列类型转换为数据类型。但是，如果序列中存在多个值，则不会引发 value error而只是返回同一个序列。我们可以通过检查返回值是否仍然是 series 类型来利用这一点。
*# Previous code* **try**:
single_value = ex_3_query[**'B_float'**].item()
print(single_value)
**except** ValueError:
print(**"Error, expected to return only one value, got %d"** %
len(ex_3_query[**'B_float'**]))*# New code* single_value = ex_3_query[**'B_float'**].squeeze()
**if** isinstance(single_value, pd.Series):
print(**"Error, expected to return only one value, got %d"** %
len(ex_3_query[**'B_float'**]))
**else**:
print(single_value)
引用:
熊猫查询 API
熊猫重采样()处理时间序列数据时你应该知道的技巧
你应该知道的一些最有用的熊猫把戏
时间序列数据在数据科学项目中很常见。通常，您可能有兴趣将时间序列数据重采样到您想要分析数据或从数据中获得更多见解的频率[1]。
在本文中，我们将介绍一些使用 Pandas resample()函数对时间序列数据进行重采样的例子。我们将讨论以下常见问题，并帮助您开始时间序列数据操作。
- 下采样和执行聚合
- 使用自定义基数缩减取样
- 向上采样和填充值
- 实际例子
源代码请查看笔记本。
1.下采样和执行聚合
下采样是将时间序列数据集重新采样到更宽的时间范围。比如从几分钟到几小时，从几天到几年。结果的行数将会减少，值可以用mean()、min()、max()、sum()等进行聚合。
让我们借助一个例子来看看它是如何工作的。
假设我们有一个关于销售的数据集。
df_sales = pd.read_csv(
'sales_data.csv',
**parse_dates=['date'],**
**index_col=['date']**
)
df_sales的例子
要获得每 2 小时增加的销售总数，我们可以简单地使用resample()将数据帧下采样到 2 小时的区间中，并对落入区间中的时间戳值求和。
df_sales.**resample('2H')**.**sum()**
resample('2H').sum()的输出
为了执行多重聚合，我们可以将聚合函数列表传递给agg()方法。
df_sales.resample('2H').**agg(['min','max', 'sum'])**
多个聚合的输出
2.自定义缩减采样base
默认情况下，对于平均细分为 1 天/月/年的频率，聚合间隔的“原点”默认为0。因此，对于2H频率，结果范围将为00:00:00、02:00:00、04:00:00、…、22:00:00。
对于我们正在使用的销售数据，第一条记录有一个日期值**2017–01–02 09:02:03** ，因此让输出范围从09:00:00开始比从08:00:00开始更有意义。为此，我们可以使用参数base将聚合间隔的“原点”设置为不同的值，例如，设置base=1，这样结果范围就可以从09:00:00开始。
df_sales.resample('2H', **base=1**).sum()
带参数base=1
3.向上采样和填充值
上采样是与下采样相反的操作。它将时间序列数据集重新采样到一个更小的时间范围。比如从几小时到几分钟，从几年到几天。结果将增加行数，额外的行值默认为NaN。常用内置方法ffill()和bfill()进行正向填充或反向填充来代替NaN。
让我们做一个数据框架来演示。
df = pd.DataFrame(
{ 'value': [1, 2, 3] },
**index=pd.period_range(
'2012-01-01',
freq='A',
periods=3
)**
)
按季度对一年进行重新采样并向前填充数值。正向填充方法ffill()将使用最后一个已知值替换NaN。
df.resample(**'Q'**).**ffill()**
df.resample('Q').ffill()
按季度对一年进行重新采样，并反向填充数值。反向填充方法bfill()将使用下一个已知值替换NaN。
df.resample(**'Q'**).**bfill()**
df.resample('Q').bfill()
4.实际例子
让我们来看看如何使用熊猫resample()来处理一个现实世界的问题。
假设我们有 2 个数据集，一个是月销售额df_sales，另一个是价格df_price。df_price只有价格变化的记录。
我们想计算每个月的 总销售额 ，预期产量如下。
计算中的难点在于，我们需要检索每个月的价格，并将其组合回数据中，以便计算总价。
一个巧妙的解决方案是使用熊猫resample()功能。一行代码可以检索每个月的价格。
步骤 1:按月对价格数据集进行重新采样，并向前填充值
df_price = df_price.**resample('M')**.**ffill()**
通过调用resample('M')按月对给定的时间序列进行重新采样。之后，调用ffill()向前填充值。你是不是有点困惑？详情请看下图。
第二步:合并结果并计算总销售额
df = **pd.concat([df_sales, df_price], axis = 1)****df['total_sales'] = df['num_sold'] * df['price']**
带参数axis=1的熊猫concat()函数用于横向组合df_sales和df_price。之后，可以使用逐元素乘法df['num_sold'] * df['price']计算总销售额。
通过执行上面的语句，您应该得到如下所示的输出:
最终输出
结论
Pandas resample()函数是一个简单、强大且高效的功能，用于在频率转换期间执行重采样操作。
我希望这篇文章能帮助你节省分析时间序列数据的时间。我建议你查看一下关于resample() API 的文档，并了解你可以做的其他事情。
感谢阅读。请查看笔记本获取源代码，如果您对机器学习的实用方面感兴趣，请继续关注。
你可能会对我的其他一些熊猫文章感兴趣:
- 如何对熊猫数据帧进行自定义排序
- 何时使用 Pandas transform()函数
- 你应该知道的熊猫串联()招数
- Pandas 中 apply()和 transform()的区别
- 使用熊猫方法链接提高代码可读性
- 在 Pandas 数据帧中处理日期时间
- 熊猫阅读 _csv()你应该知道的招数
- 你应该知道的用熊猫 read_csv() 解析日期列的 4 个技巧
更多教程可以在我的 Github 上找到
参考
熊猫——用这些简单的技巧节省记忆
如何在内存使用方面更高效地使用熊猫
处理小型数据时，内存不是一个大问题。然而，当涉及到大型数据集时，有效地使用内存就变得势在必行。我将介绍一些非常简单的技巧来减小熊猫数据帧的大小。我将使用 Kaggle 上关于加密货币市场价格的相对较大的数据集。让我们从将数据读入熊猫数据帧开始。
import pandas as pd
import numpy as npdf = pd.read_csv("crypto-markets.csv")
df.shape
(942297, 13)
数据帧有将近一百万行和 13 列。它包括加密货币的历史价格。
让我们检查一下这个数据帧的大小:
df.memory_usage()
Index 80
slug 7538376
symbol 7538376
name 7538376
date 7538376
ranknow 7538376
open 7538376
high 7538376
low 7538376
close 7538376
volume 7538376
market 7538376
close_ratio 7538376
spread 7538376
dtype: int64
memory_usage()返回每行使用多少内存(以字节为单位)。我们可以通过几个数学运算来检查完整数据帧的内存使用情况，单位为兆字节:
df.memory_usage().sum() / (1024**2) #converting to megabytes
93.45909881591797
所以总大小是 93.46 MB。
让我们检查一下数据类型，因为在某些情况下，我们可以用更易于存储的数据类型来表示相同数量的信息。
df.dtypes
slug object
symbol object
name object
date object
ranknow int64
open float64
high float64
low float64
close float64
volume float64
market float64
close_ratio float64
spread float64
dtype: object
首先想到的应该是“对象”数据类型。如果我们有分类数据，最好使用“类别”数据类型而不是“对象”,尤其是当类别的数量与行数相比非常低的时候。“slug”、“symbol”和“name”列就是这种情况:
df.slug.value_counts().size
2071
有 2072 个类别，相对于 100 万行是非常低的。让我们将这些列转换为“category”数据类型，并查看内存使用的减少情况:
df[['slug','symbol','name']] = df[['slug','symbol', 'name']].astype('category')df[['slug','symbol','name']].memory_usage()
Index 80
slug 1983082 #previous: 7538376
symbol 1982554
name 1983082
dtype: int64
因此每列的内存使用减少了%74。让我们看看我们总共存了多少钱:
df.memory_usage().sum() / (1024**2) #converting to megabytes
77.56477165222168
总大小从 93.46 MB 减少到 77.56 MB。
“ranknow”列显示不同货币类别之间的排名。既然有 2072 个类别，那么最大值应该是 2072。
df.ranknow.max()
2072
“ranknow”列的数据类型是 int64，但是我们也可以使用 int16 表示从 1 到 2072 的范围。int16 可以表示的范围是-32768 到+32767。
df["ranknow"] = df["ranknow"].astype("int16")df["ranknow"].memory_usage()
1884674 #previous: 7538376
因为我们从 int64 降低到 int16，所以内存使用如预期的那样减少了%75。
数据集中的浮点数用“float64”表示，但我可以用“float32”表示这些数字，这样我们就可以有 6 位数的精度。我认为 6 位数就足够了，除非你是在做高灵敏度的测量。
- float32(等效 C 类型:float): 6 位精度
- float64(等效 C 类型:double): 15 位精度
floats = df.select_dtypes(include=['float64']).columns.tolist()df[floats] = df[floats].astype('float32')df[floats].memory_usage()
Index 80
open 3769188 #previous: 7538376
high 3769188
low 3769188
close 3769188
volume 3769188
market 3769188
close_ratio 3769188
spread 3769188
dtype: int64
从“float64”到“float32”的转换如预期的那样将这些列的内存使用量减少了%50。
float32 有 6 位精度
在某些情况下，数据帧可能有冗余列。让我们看一下现有的数据框架:
“slug”、“symbol”、“name”等栏目以不同的格式表示同一事物。这三列中只有一列就足够了，所以我可以删除两列。您拥有的数据帧可能没有这样的列，但寻找冗余或不必要的列总是一个好的做法。例如，数据帧可能包括“计数”、“值”和“总和”列。我们可以很容易地获得总数乘以计数和值，所以总和列是不必要的。有些列可能与你想完成的任务完全无关，所以只需寻找这些列。在我的例子中，我将删除“符号”和“名称”列，并使用“slug”列:
df.drop(['symbol','name'], axis=1, inplace=True)
让我们检查最终数据帧的大小:
df.memory_usage().sum() / (1024*1024)
39.63435745239258
总大小从 93.46 MB 减少到 36.63 MB，我认为这是一个伟大的成就。我们能够节省 56，83 MB 的内存。
减小尺寸的另一个优点是简化计算。使用 float32 进行计算比使用 float64 花费的时间少。
我们应该尽可能地寻找减小尺寸的方法。
感谢您的阅读。如果您有任何反馈，请告诉我。
熊猫系列&数据框讲解
理解 Pandas 系列和 DataFrame 数据结构的综合指南
介绍
作为一名成功的数据科学家，需要不断学习和提高我们使用各种工具的技能。如今，与数据科学同义的一个工具是熊猫。Pandas 是一个非常强大的开源库，用 Python 编写。它提供了一套多样化的工具，我们作为数据科学家可以用来清理、操作和分析数据。今天我们从基础开始，学习熊猫中最常见的两种数据结构系列和数据框架。
入门指南
安装熊猫& Numpy
Pandas 和 Numpy 是用 Python 编写的开源库，你可以在你的 Python 脚本中使用它们。有几种方法可以安装这些软件包。默认情况下，如果您使用的是 Anaconda ，这些包已经安装好了。如果您没有使用 Anaconda，那么最简单的安装选项是使用pip，这是 Python 推荐的安装包。您可以在 PyPA 的文档中找到pip的详细安装说明。
一旦pip完成安装，您可以在终端上运行以下命令来安装 Pandas 和 Numpy pip install pandas pip install numpy。安装后，您可以使用下面的语法将 Pandas 和 Numpy 库导入到您的脚本中。
上面的 Python 片段显示了导入 Pandas 和 Numpy 包的语法。
熊猫系列
Pandas 系列数据结构是一个一维标签数组。它是数据帧的主要构造块，构成数据帧的行和列。您可以查看以下系列的构造函数。
上面的 Python 片段显示了熊猫系列的构造函数。
data参数可以接受几种不同的数据类型，如n 数组、字典和标量值。index参数接受类似数组的对象，这将允许您标记索引轴。如果您没有向index参数传递一个条目，而向data参数传递一个字典，那么 Pandas 将使用字典键作为索引标签。您可以通过设置dtype参数来设置系列的数据类型。如果一个数据类型没有被指定，那么 Pandas 将会对数据类型进行推断。name参数如其所暗示的那样，允许您命名您已经创建的系列。
使用字典创建系列
下面我们提供了一个示例 Python 片段，您可以使用它来创建一个系列。
上面的 Python 片段演示了如何使用字典创建和命名一个系列。
上图显示了执行 Python 代码片段创建系列的结果。
从上面的控制台输出中，我们可以看到该系列使用了字典键作为索引，该系列被命名为series_from_dict，Pandas 推断出一个数据类型为float64。
从 ndarray 创建系列
生成测试序列的最快方法之一是使用 NumPy 的random.randint(),它产生一个填充了随机整数的 ndarray。
上面的 Python 片段演示了如何使用 ndarray 创建和命名一个系列。
上图显示了执行 Python 代码片段的结果。
从标量值创建序列
我们今天要看的最后一个方法是使用标量值创建一个序列。在这里，您可以为data分配一个值，并在索引长度内重复该值。
上面的 Python 片段展示了如何通过传递标量值来创建序列。
上图显示了执行 Python 代码片段的结果。
熊猫数据框
Pandas DataFrame 是由列和行组成的二维数据结构。您可以将 DataFrame 视为类似于 CSV 或关系数据库表。下面你可以看到创建数据帧的构造函数。
上面的 Python 片段显示了熊猫数据帧的构造函数。
与 Series 类似的data参数可以接受广泛的数据类型，例如 Series、Series 字典、结构化数组和 NumPy 数组。除了能够将索引标签传递给index，DataFrame 构造函数还可以通过columns接受列名。
为系列词典创建数据框架
生成数据帧最简单的方法之一是创建一个包含 Series 的字典。字典键将成为数据帧的列标签，而系列索引将成为数据帧的行标签。下面是一个 Python 片段，您可以用它来生成您的第一个数据帧。
上面的 Python 片段展示了如何使用系列字典创建 DataFrame。
上图显示了执行 Python 脚本的结果。
上面的控制台输出清楚地展示了 DataFrame 数据结构。字典关键字column_a、column_b和column_c现在形成了带标签的列，序列索引a、b、c、d和e是数据帧行标签。
为列表字典创建数据框架
Pandas DataFrame 构造函数也可以接收一个列表字典。下面我们为您提供了一个 Python 片段，您可以使用它来实现这一点。这里，我们通过 DataFrame 构造函数中的index参数分配了行标签。
上面的 Python 片段展示了如何从列表字典创建 DataFrame。
上图显示了从列表字典创建 DataFrame 的结果。
接下来去哪里？
既然您已经介绍了 Pandas 的基本构件，您的下一步应该是学习如何通过迭代数据帧或使用 Pandas Profiling 进行分析来导航数据帧。
再次感谢您花时间阅读我们的故事，我们希望您发现它有价值！
熊猫侧桌刚刚宣布
对数据框架的信息丰富、见解深刻的概述。
Pandas 是一个非常强大和通用的 Python 数据分析库，它加速了数据科学项目的预处理步骤。它提供了许多在数据分析中非常有用的函数和方法。
虽然熊猫的内置功能能够执行有效的数据分析，但定制的功能或库为熊猫增加了价值。在本帖中，我们将探究其中一个附加组件。
昨天，克里斯·莫菲特宣布了一个新的名为 sidetable 的熊猫实用程序库。这里是 sidetable 的 github repo 。我发现它非常有用，并计划在我的日常分析中应用。这就是为什么我想通过一些例子来分享和传播这个词。
Sidetable 基于选定的列创建频率表。假设我们有一个数据集，其中包含某个分类变量的一些测量值(例如模型)。我们有许多不同的模型，每个模型都有许多观察值(行)。通过使用 sidetable，我们可以得到一个概览，显示每个模型在数据集中所占的份额。这也可以使用 pandas 的**value_counts**功能来实现，但是 sidetable 提供的信息更多，我们将在示例中看到。
如果你使用 jupyter 笔记本，我们首先需要用pip或!pip安装它:
!pip install sidetable
然后导入它:
import pandas as pd
import sidetable
我们现在可以使用 stb 作为数据帧的存取器。我将使用 kaggle 上可用的美国汽车数据集。它包含了拍卖的二手车的数据。
df = pd.read_csv("/content/USA_cars_datasets.csv")#drop redundant columns
df.drop(['Unnamed: 0','vin','lot'], axis=1, inplace=True)df.head()
我们可能想看看主导品牌是什么。一种方法是使用value_counts功能。数据集中出现次数最多的 10 个品牌:
df.brand.value_counts()[:10]ford 1235
dodge 432
nissan 312
chevrolet 297
gmc 42
jeep 30
chrysler 18
bmw 17
hyundai 15
kia 13 Name: brand, dtype: int64
我们可以通过使用归一化参数来获得频率比:
df.brand.value_counts(normalize=True)[:10]ford 0.494198
dodge 0.172869
nissan 0.124850
chevrolet 0.118848
gmc 0.016807
jeep 0.012005
chrysler 0.007203
bmw 0.006803
hyundai 0.006002
kia 0.005202 Name: brand, dtype: float64
数据集中几乎 50%的汽车都是福特的。这比只看到计数更能提供信息。Sidetable 更进了一步。
df.stb.freq(['brand'])[:10]
Sidetable 返回每个品牌的计数和百分比以及累计值。肯定比**value_counts**信息量大。我们对数据集中的分布有了更多的了解。累积值的一个额外特性是我们可以设置累积百分比的阈值。然后，达到阈值后的类别被标记为“其他”。我们也可以使用 other_label 参数为“其他”指定一个标签。例如，我们可能希望看到构成数据集 90%的品牌。
df.stb.freq(['brand'], thresh=.9, other_label='other brands')
我们也可以通过多列，看到更具体的分布。让我们看看数据集中排名靠前的品牌年份组合。
df.stb.freq(['brand','year'], thresh=.5)
福特以 50%的份额在数据集中占据主导地位。大多数福特汽车都是 2019 款，占整个数据集的 19%。请注意，19%表示整个数据集中的比率，而不仅仅是福特品牌中的比率。为了获得福特品牌的分布情况，我们可以对数据帧应用过滤器。
df[df.brand == 'ford'].stb.freq(['year'], thresh=.9)
我们可以看到，2019 款福特汽车占所有福特品牌汽车的 38%。回想一下前面的例子，2019 款福特汽车占据了整个数据集的 19%。
sidetable 的另一个有用特性是它提供了基于值的分布。例如，我们可以检查每个品牌汽车的总价。要聚合的列被传递给值参数。
df.stb.freq(['brand'], value='price', thresh=.95)
数据集中福特汽车的总价超过 2600 万，占所有汽车总价的 57%。回想一下前面的例子，数据集中 49%的汽车是福特品牌的。就总价而言，这一比例上升至 57%，表明福特汽车的平均价格高于其他品牌的平均价格。当然，还有其他因素会对价格产生影响，比如年份、里程、所有权状况等等。但是，它提供了一个一般的洞察力。
如果值的格式看起来不吸引人，可以使用样式参数进行更改。
df.stb.freq(['brand'], value='price', thresh=.95, style=True)
我认为熊猫的成功和流行来自于其多功能、强大且易于使用的操作和分析数据的功能。和熊猫一起完成一项任务几乎总是有多种方式。熊猫上添加的定制实用程序库优化了某些操作，并为熊猫带来了更多价值。再次感谢克里斯·莫菲特提供的这个有价值的工具。
由于花在数据科学项目上的大部分时间都花在了数据清理和预处理步骤上，Pandas 是您武库中的宝贵资产。
感谢您的阅读。如果您有任何反馈，请告诉我。
熊猫串操作—解释
如何操作文本数据
Ashkan Forouzani 在 Unsplash 上的照片
我们必须用数值来表示每一位数据，以便由机器学习和深度学习模型进行处理和分析。然而，字符串通常不会有一个好的和干净的格式，需要大量的预处理。Pandas 提供了许多多功能函数来修改和处理字符串数据。在讨论字符串操作之前，最好提一下 pandas 是如何处理字符串数据类型的。
对象 vs 字符串
在 pandas 1.0 之前，只有“object”数据类型用于存储字符串，这导致了一些缺点，因为非字符串数据也可以使用“object”数据类型存储。Pandas 1.0 引入了一个新的特定于字符串数据的数据类型string type。到目前为止，我们仍然可以使用 object 或 string type 来存储字符串，但是在将来，我们可能会被要求只使用 string type。
这里需要注意的一点是，对象数据类型仍然是字符串的默认数据类型。要使用 StringDtype，我们需要显式声明它。
我们可以通过“字符串或 **pd。用于选择字符串数据类型的 Dtype 参数的 string type()**参数。
import pandas as pd
import numpy as np
另一种方法是使用 astype 函数转换为“字符串”。
字符串操作
- 上下
谈到字符串，首先想到的是小写和大写字母。对 as 来说可能没什么大不了的，但是“A”和“A”就像“A”和“k”或任何其他字符对计算机来说一样不同。
**上()和下()**的方法可以用来解决这个问题:
- 剥离
如果字符串的开头或结尾有空格，我们应该修剪字符串以消除空格。剥离的方法可以用来做这个任务:
还有 lstrip 和 rstrip 方法分别删除前后空格。
- 拆分
有时字符串携带不止一条信息。为了利用不同种类的信息，我们需要拆分字符串。而这里用的方法是分割，令人惊讶。
我们只需要将字符传递给 split。默认字符是空格或空字符串(str= ’ ')，所以如果我们要根据任何其他字符进行拆分，就需要指定它。
字符串被拆分，新元素被记录在一个列表中。通过传递索引，可以使用 [] 或 get 方法来访问列表中的元素。
我们也可以在拆分后用新元素创建一个数据帧。扩展参数设置为真创建一个数据帧。
如果一行没有足够的元素来匹配其他行，则单元格中不填充任何元素。我们也可以限制分裂的次数。默认情况下，分割从左边开始，但是如果我们想从右边开始，应该使用 rsplit 。
- 卡特彼勒
正如我们在某些情况下需要拆分字符串一样，我们可能需要组合或连接字符串。 Cat 方法用于连接字符串。
我们需要使用 sep 参数传递一个参数放在连接的字符串之间。默认情况下，cat 忽略缺失值，但是我们也可以使用 na_rep 参数指定如何处理它们。
我们还可以进行元素级的连接(即向序列中的每个字符串添加一个字符串):
假设字符串是从左到右索引的，我们可以使用 str[] 访问每个索引。用例子来解释更好:
如果字符串没有指定的索引，则返回 NaN。
- 开始和结束
我们可以分别使用以开头的和以结尾的来选择字符串。
- 得到假人
我们可以从序列中提取虚拟变量。这在编码分类变量时特别有用。
这种表示需要将分类变量输入到机器学习模型中。
如果一个字符串包含多个值，我们可以首先使用 sep 参数进行拆分和编码:
- 镜头
在某些情况下，我们需要数据帧的一系列或一列中字符串的长度。为了得到每个字符串的长度，我们可以应用 len 方法。请记住，len 也用于获取一个系列或数据帧的长度。让我们用例子来看看不同之处:
Pandas 字符串操作并不局限于我们在这里讨论的内容，但是我们讨论的函数和方法肯定会有助于处理字符串数据并加快数据清理和准备过程。
感谢阅读。如果您有任何反馈，请告诉我。
熊猫小贴士我希望我以前就知道
pivot 是如何工作的？熊猫的主要构件是什么？还有更多…
伊洛娜·弗罗利希在 Unsplash 上的照片
我成为熊猫超级用户已经有几年了。有时候我认为我已经掌握了它，但是几个月后我发现我像个菜鸟一样编程。我们都经历过😊我在这里与你分享的技巧是我最近学到的。
要运行示例，请下载这个 Jupyter 笔记本。
这里有几个你可能会感兴趣的链接:
- [Complete your Python analyses 10x faster with Mito](https://trymito.io/) [Product]- [Free skill tests for Data Scientists & ML Engineers](https://aigents.co/skills) [Test]- [All New Self-Driving Car Engineer Nanodegree](https://imp.i115008.net/c/2402645/1116216/11298)[Course]
你愿意阅读更多这样的文章吗？如果是这样，你可以点击上面的任何链接来支持我。其中一些是附属链接，但你不需要购买任何东西。
让我们从一个爆炸性的提示开始💥
从 giphy 下载的 Gif
熊猫有爆炸的功能。别担心，使用它是完全安全的😊当 DataFrame 列中存储有列表时，该函数非常有用。它解包列表中的值，并复制所有其他值，因此会爆炸💥
让我们创建一个 DataFrame，它的一列在列表中有随机数量的元素。
n = 10
df = pd.DataFrame(
{
"list_col": [[random.randint(0, 10) for _ in range(random.randint(3, 5))] for _ in range(10)],
}
)
df.shape(10, 1) # output
现在，让我们执行 explode 函数。
df = df.explode("list_col")
df.shape(40, 1) #output
在下表中，我们可以观察到由于从列表中解包值，索引被重复。
数据帧不是熊猫的主要构件
迷因创造了imgflip.com
Pandas 几乎是 DataFrames 的同义词，但如果我告诉你它不是它的主要构建块，你可能会感到惊讶。熊猫数据框架是建立在熊猫系列之上的。所以数据帧中的每一列都是一个系列。我们可以更深入，熊猫系列是基于什么？Numpy！但是我们不要走那么远。
当收益超过在项目中安装 pandas 的成本时，我甚至将 Python 的 list 包含在 pandas 系列中——我这里指的是后端，而不是分析项目。
让我们用窗口 2 计算一个列表中值的滚动和。
values = [1, 2, 0, 0, 0, 0, 1, 2, 3]
sr = pd.Series(values)
sr.rolling(2).sum()
这样代码就更简洁了。
Pivot —数据科学家的必备工具
从 giphy 下载的 Gif
什么是支点？数据透视表是一个统计表，它汇总了一个更广泛的表中的数据。听起来很有用！让我们试一试。
假设我们有一家水果店和几个顾客。
df = pd.DataFrame(
{
"fruit": ["apple", "orange", "apple", "avocado", "orange"],
"customer": ["ben", "alice", "ben", "josh", "steve"],
"quantity": [1, 2, 3, 1, 2],
}
)
现在，让我们用 fruit 和 customer 列以及聚合数量值来透视表。我们期待一张桌子，水果在一个轴上，顾客在另一个轴上。应合计数量值
df.pivot(index="fruit", columns="customer", values="quantity")
我们得到一个“值错误:索引包含重复条目，无法整形”。这是什么意思？
让我们用一个不同的命令(但是更容易解释)来尝试 pivot，它与 pivot 函数具有相同的效果。
df.set_index(["fruit", "customer"])["quantity"].unstack()
该命令返回与 pivot 函数相同的错误，但是更清楚幕后发生了什么。水果列和客户列组合在一起时似乎没有唯一的索引。
现在，让我们尝试使用 pivot_table 函数，这也是推荐的方法。注意，该函数还支持 aggfunc，默认情况下是 np.mean。我们在下面的例子中使用 np.sum。
df.pivot_table(index="fruit", columns="customer", values="quantity", aggfunc=np.sum)
很少值得一提
从 giphy 下载的 Gif
访问元素
访问数据帧中的第一个元素(和最后一个元素)非常简单:
df = pd.DataFrame({"col": [1, 2, 3, 4, 5]})df.iloc[0]df.iloc[-1] # the last element
你可能会问 loc 和 iloc 有什么区别？当通过索引访问行时，我们使用 loc，其中索引可以是字符串、整数或其他类型。
我们还使用 loc 在某个索引上设置一个新的列值(我们不能用 iloc 这样做—它会返回 ValueError):
df.loc[0, "col"] = 1
追加值
Pandas 有一个 append 函数，使您能够将值追加到数据帧中。但是技巧是附加的值也需要在数据帧中。
df = df.append(pd.DataFrame({'col': [999]}))
df
行到列
我最喜欢的将行变成列的方法是使用转置。它在 numpy 中也有效。
df.T
在你走之前
在推特上关注我，在那里我定期发关于数据科学和机器学习的推特。
照片由Courtney hedge在 Unsplash 上拍摄
熊猫给你的建议会让你省去几个小时的挠头时间
从长远来看，使您的数据分析实验具有可重复性可以为您和他人节省时间
当重新审视你过去处理过的问题时，发现代码不起作用是令人沮丧的。从长远来看，使您的数据分析实验具有可重复性可以为您和他人节省时间。这些提示将帮助您编写可重复的 pandas 代码，当您在团队中工作时，这对于您计划在未来重新访问或与其他人共享的个人项目非常重要。
要运行示例，请下载这个 Jupyter 笔记本。
这里有几个你可能会感兴趣的链接:
- [Labeling and Data Engineering for Conversational AI and Analytics](https://www.humanfirst.ai/)- [Data Science for Business Leaders](https://imp.i115008.net/c/2402645/880006/11298) [Course]- [Intro to Machine Learning with PyTorch](https://imp.i115008.net/c/2402645/788201/11298) [Course]- [Become a Growth Product Manager](https://imp.i115008.net/c/2402645/803127/11298) [Course]- [Deep Learning (Adaptive Computation and ML series)](https://amzn.to/3ncTG7D) [Ebook]- [Free skill tests for Data Scientists & Machine Learning Engineers](https://aigents.co/skills)
上面的一些链接是附属链接，如果你通过它们购买，我会赚取佣金。请记住，我链接课程是因为它们的质量，而不是因为我从你的购买中获得的佣金。
要升级你的熊猫游戏，请阅读:
一个开源项目，简化了熊猫与实时数据的连接，测试假设和可视化…
towardsdatascience.com](/pandas-analytics-server-d9abceec888b)
输出版本
为了使您的 pandas 实验可重复，从输出系统信息和 python 包的版本开始。你(或你的同事)可以以后再感谢我。在某个包的旧版本中，某些功能可能被弃用、损坏或不可用。注意，Python 包是特意用==打印出来的，这样您就可以直接使用 pip 的输出来安装它们。
我使用下面的模板来输出系统信息和包的版本。
import os
import platform
from platform import python_versionimport jupyterlab
import numpy **as** np
import pandas **as** pd**print**("System")
**print**("os name: %s" **%** os**.**name)
**print**("system: %s" **%** platform**.**system())
**print**("release: %s" **%** platform**.**release())
**print**()
**print**("Python")
**print**("version: %s" **%** python_version())
**print**()
**print**("Python Packages")
**print**("jupterlab==%s" **%** jupyterlab**.**__version__)
**print**("pandas==%s" **%** pd**.**__version__)
**print**("numpy==%s" **%** np**.**__version__)
对自动导入说不
我曾经有过一个很棒的想法，不要每次都写。Jupyter 笔记本可以自动导入它们。
听起来很棒？嗯，结局不太好。过了一会儿，我忘记了我的定制配置，不久之后我就收到了类似这样的问题:“你运行代码了吗，因为它在第一行就失败了！”，“这段代码在你的机器上是如何工作的？”。
对自动进口说不。
播种
使用随机生成的数据时，必须设置种子。如果您正在使用机器学习模型，您还应该设置随机种子(如果可用)，以便模型返回确定性输出。
让我们看看例子。我们设置随机种子并输出一个包含 10 个伪随机数的随机样本。正如所料，第二次运行与第一次运行有不同的伪随机数。注意，熊猫在引擎盖下使用 numpy，所以我们需要用 numpy 设置种子。
np**.**random**.**seed(42)np**.**random**.**random_sample(10)# Outputarray([0.37454012, 0.95071431, 0.73199394, 0.59865848, 0.15601864,
0.15599452, 0.05808361, 0.86617615, 0.60111501, 0.70807258]) np**.**random**.**random_sample(10)# Outputarray([0.02058449, 0.96990985, 0.83244264, 0.21233911, 0.18182497,
0.18340451, 0.30424224, 0.52475643, 0.43194502, 0.29122914])
当我们再次设定相同的种子时会发生什么？我们重置种子，得到与上面相同的数字序列。这使得确定性伪随机数发生器。
np**.**random**.**seed(42)np**.**random**.**random_sample(10)# Outputarray([0.37454012, 0.95071431, 0.73199394, 0.59865848, 0.15601864,
0.15599452, 0.05808361, 0.86617615, 0.60111501, 0.70807258])
评论
一个有 10 行 pandas 代码的代码块很可能被一个 pandas 专家重写为 5 行，但是代码的可理解性受到影响。随着工具越来越好，我们也倾向于做同样的事情。今天我们可能知道代码做了什么，但是一个月后我们会记得吗？初级分析师会知道这是什么吗？
大概不会！当代码变得复杂时，你应该写一两条注释。不只是在用熊猫做数据分析的时候，而是在一般编码的时候。
安全检查
写安全检查而不是注释，比如“这部分代码不支持空值或重复”。这将花费相同的时间，但是用户肯定会注意到安全检查，因为在出现问题的情况下，它们会中断执行。
让我们看看下面的例子。
df **=** pd**.**DataFrame(index**=**[1, 2, 3, 4, 4], data**=**{"col1": ["a", "b", "c", "d", "d"]})
数据帧具有重复的索引值 4。我们可以使用重复的函数来检测重复的索引，然后用 assert 语句中断执行。
**assert** len(df[df**.**index**.**duplicated()]) **==** 0, "Dataframe has duplicates"
格式化代码
Jupyter 笔记本因无格式、丑陋的代码而臭名昭著。主要原因是早期版本没有代码格式化程序。在他们这样做之后，安装它们就不是一件小事了。但现在情况不同了。
我将 jupyterlab-code-formatter 与 jupyterlab 一起使用，效果很好。这里是安装指南。如果你需要任何安装帮助，请在评论中告诉我。
格式正确的代码会增加你不扔掉它重新开始的机会。
输出数据帧的形状
我发现在每次转换后输出数据帧的形状是一个很好的实践。这有助于在读取、合并等操作后发现错误的行数或列数。这样，我们只需检查 shape 函数的输出就可以发现错误，而无需重新运行笔记本。
让我们将示例数据帧与其自身进行内部连接。它只有 5 行，所以我们希望新的数据帧也有 5 行。
df**.**shape(5, 1)
新数据帧有 7 行，而不是 5 行。
df_new **=** df**.**join(df, lsuffix**=**'_l', rsuffix**=**'_r')
df_new**.**shape(7, 2)
我们看到问题的出现是因为一个重复的索引。通过使用 shape 函数，我们可以立即发现一个 bug。
df_new
提出可重复的问题
有些情况下，我们有输入数据，我们知道输出应该是什么样子，但我们不知道如何编写中间的步骤(我们都经历过)。下一步通常是询问关于堆栈溢出或 Reddit 的问题，或者向同事寻求帮助。
通过编写可重复的问题，我们可以使协作解决问题变得更加容易:
- 简明扼要地描述问题的核心，不要通过复制粘贴实验的一半而陷得太深，
- 使用可以在单行中初始化的小数据帧(不要引用本地数据集)，
- 使用 slack 时，用``将代码块中的代码换行。
一个好的做法是使 DataFrame 输出易于复制粘贴。没听说过？我举个例子解释一下。
df# Copy-paste output col1
1 a
2 b
3 c
4 d
4 d
Pandas 有一个 read_clipboard 方法，顾名思义就是这样做的。我们可以复制上面的输出并运行下面的命令，它将复制数据帧。你自己试试。如果需要，我们也可以将分隔符更改为制表符\t或任何其他分隔符。
df **=** pd**.**read_clipboard(sep**=**'\s\s+')
df
这个复制-粘贴过程不适用于 MultiIndex。所以提问的时候尽量避开他们。
结论
这些是让你的熊猫实验可重复的几个小技巧。你喜欢这个职位吗？请在下面的评论中告诉我。
在你走之前
在推特上关注我，在那里我定期发关于数据科学和机器学习的微博。
照片由Courtney hedge在 Unsplash 上拍摄
熊猫在每个城镇寻找最可爱的猫
熊猫的有趣介绍——Python 数据分析库
嗨，在的上一篇文章中，我们看到了使用 SQL 和 Elasticsearch 解决典型的每组最大数量的问题。本文将探讨如何使用强大的 Python 数据分析库 Pandas 来解决这个问题。🐼
熊猫得到了两个重要的数据结构系列和数据帧。我们将探索 Pandas DataFrame 数据结构和它的一些功能来解决我们的问题。说问题，没看过上一篇的我来解释一下。在一个城镇里，会有许多可爱的猫。我们要从每个镇只挑一只最可爱的猫，它的名字叫喵(或者类似喵，以后会看到)。
如果你想跟进，我建议你参考熊猫官方网站进行本地设置，或者你可以在 Kaggle 上创建一个新的笔记本。甚至提交你的 Kaggle 找喵任务的解决方案。
让我们用一个小的猫的数据集，列 id，猫的名字，城镇，可爱程度从 1 到 10，10 是最可爱的。
资料组
该数据集的预期输出为:
预期结果
首先，我们将 pandas 库作为pd导入，并用样本数据集创建一个数据帧df。有许多方法可以创建数据帧。下面我提供了三个选项。选项 1 使用字典；选项 2，通过加载本地可用的 CSV 文件；选项 3 从 URL 读取 CSV 文件。
一旦创建了数据帧，就可以使用df.head()方法从数据帧中获取前 5 行。可选地，您可以传递要检索的行数，比如df.head(10)，检索前 10 行。
创建数据框架
类似于df.head(n)方法，有df.tail(n)返回最后 n 条记录。
df.tail()
df.columns将返回所有的列名。
df.shape返回表示数据帧维度的元组。比如我们的 DataFrame，(10，4)，这意味着 10 行 4 列。
df.size返回一个表示该对象中元素个数的 int。比如我们的数据帧，40 (10*4)
数据帧信息
为了获得数据帧的简明摘要，我们可以使用df.info()。我们的数据有 4 个非空列，每个列有 10 个条目。id和cuteness为表示数字的int64数据类型。name和town作为一个object。如果您正在处理一些未知的数据，这可能是方便的信息。
其中df.info提供关于数据类型、内存使用等的信息。，我们可以使用df.describe()来获得统计数据。你可以参考官方的文件来理解这些数字的含义。
数据帧描述
要引用特定的列数据，您可以像df['town']一样访问并对其执行查询。想要获得列 town 的唯一值，我们可以运行df['town'].unique()。或者获取每个城镇的值计数，df['town'].value_counts()。根据我们的数据，我们在德里有 4 只猫，在孟买和班加罗尔各有 2 只猫& Meerut，我们必须在每个城镇中找出 1 只最可爱的猫。
唯一计数
要查看每个城镇每列的最大值，我们可以按城镇对数据进行分组，并使用 max 函数。如果你看下面的结果，乍一看，它可能似乎是我们问题的解决方案(忽略名称条件)，但它肯定不是。像我前面说的，它分别返回每一列的最大值**。如您所见，我们没有 id 和姓名为 5、tom 可爱度为 10 的记录。尽管我们在班加罗尔的最大 id 是 8。同样，在密鲁特和孟买，9 是最大的可爱。**
最大
要找到名为喵的猫，我们必须添加过滤器。我们可以通过多种方式查询数据。比如df[df['name']=='meow']或者使用df.query()执行字符串查询。本文将使用前一个。但是，在某些情况下，后一种方法可能更有用，比如您从一些外部来源获取这些查询。
询问
根据我们的任务，我们不仅要寻找猫名"喵",还要寻找听起来相似的猫名。所以将修改我们的搜索查询来查找包含喵的名字。我们将如何使用.str将列转换为字符串，并使用字符串的 contains 方法。看看下面的搜索结果，现在我们有了猫的子集，它们的名字叫喵或者听起来像喵。
包含查询
对于猫的子集，让我们按城镇将它们分组，并找出每个城镇的最大可爱程度。这给了我们每个城镇最大的可爱度，但是我们还没有从这个结果中识别出猫。我们丢失了一些列，如 id 和 name。
分组依据
因此，不是取出可爱列并对其应用一个max函数，而是对整个DataFrameGroupBy对象应用一个 lambda 函数，返回一个以城镇为索引的数据帧。如果你检查下面的结果，现在我们有城镇作为一个列和一个索引。
分类
现在有了这个数据框架，我们可以再次按城镇分组，并从每个组中获得第一个条目，这就是我们的解决方案。但是如果我们这样做，我们会得到一个异常，因为town既是一个索引级别又是一个列标签，这是不明确的。
错误
我们能做的是在做另一个 group by 之前重置索引。我们可以在df.reset_index(drop**=**True)前完成。drop=True选项将避免索引作为一列添加到结果数据帧中。或者更好的是，我们可以使用groupby方法的现有选项as_index=False，这将产生类似的结果。
看看下面的解决方案，我们可以在每个城镇找到名字为喵或与之相似的最可爱的猫。
但是它与我们预期的解决方案不匹配😳。对于德里，我们期待 id 为 5 的猫，而不是 3。我们遗漏了任务的一部分，我们必须优先选择名字叫喵的猫，而不是名字听起来像喵的猫。
解决办法
为此，一种方法是我们添加另一个得分字段。假设猫的名字不能超过 100 个单词，我们可以使用公式(cuteness of cat * 100) — length of the name给每只猫打分。所以即使两只猫的可爱度都是 10。喵喵猫会得分10*100-4 = 996，卡米诺会得分10*100-6 = 994。有趣的是，我们的分数不会因为可爱程度不同而重叠。比如，如果可爱度是 10，分数将在范围10*100-100 = 900到10*100-4 = 996之间。如果可爱度是 9，分数将在9*100-100 = 800到9*100-4 = 896的范围内。所以我们可以安全地使用这个公式。
要向我们的 DataFrame 添加一个新列，我们可以简单地做如下的事情。
新列
所以现在对于我们的最终解决方案，我们可以用可爱度排序代替 total _ score，我们得到了正确的结果。🤗
最终解决方案
感谢阅读！如果你有任何疑问或者你觉得你知道一个更好的方法来“找到喵”，请发表评论
页（page 的缩写）准备好迎接每镇最可爱的猫挑战了吗？在推特上发布你对熊猫的最佳解决方案，标签为# 每镇最可爱的猫，#findingmeow 👨💻或者下面评论。如果我们发现您的解决方案比我们的更好，我们将附上您的姓名和您提交的内容。
熊猫输入缺失数据的技巧
用熊猫输入数据
数据科学家面临的最大挑战之一是处理缺失数据。在本帖中，我们将讨论如何使用熊猫来估算缺失的数值和分类值。
我们开始吧！
出于我们的目的，我们将使用葡萄酒杂志数据集，它可以在这里找到。
首先，让我们将数据读入熊猫数据框:
import pandas as pd
df = pd.read_csv("winemag-data-130k-v2.csv")
接下来，让我们使用。head()'方法:
print(df.head())
因为我们对输入缺失值感兴趣，所以查看缺失值在各列中的分布会很有用。
我们可以用’来显示丢失的值信息。“info()”方法。这将显示每列中非空值的数量:
print(df.info())
我们也可以使用。isnull()“和”。sum()'方法计算每列中缺失值的数量:
print(df.isnull().sum())
我们看到生成的 Pandas 系列显示了数据中每一列的缺失值。“价格”列包含 8996 个缺失值。我们可以使用’替换这些丢失的值。fillna()”方法。例如，让我们用平均价格填充缺失值:
df['price'].fillna(df['price'].mean(), inplace = True)
print(df.isnull().sum())
我们看到“价格”列不再有缺失值。现在，假设我们想做一个更精确的估算。一个好的猜测是用缺少的值所属国家的平均价格替换价格列中缺少的值。例如，如果我们考虑意大利葡萄酒缺失的葡萄酒价格，我们可以用意大利葡萄酒的平均价格替换这些缺失的值。接下来，让我们看看“国家”值的分布。我们可以使用集合模块中的“Counter”方法来实现:
from collections import Counter
print(Counter(df['country']))
让我们来看看美国制造的葡萄酒。我们可以定义一个只包含“美国”葡萄酒的数据框:
df_US = df[df['country']=='US']
现在，让我们打印缺失值的数量:
print(df_US.isnull().sum())
我们看到在“美国”葡萄酒数据中有 239 个缺失的“价格”值。为了用对应于美国价格的平均值填充缺失值，我们执行以下操作:
df_US['price'].fillna(df_US['price'].mean(), inplace = True)
现在，假设我们想对每个国家缺失的价格值进行这样的计算。首先，让我们估算缺失的国家值:
df['country'].fillna(df['country'].mode()[0], inplace = True)
接下来，在 for 循环中，我们可以定义特定于国家的数据帧:
for i in list(set(df['country'])):
df_country = df[df['country']== country]
接下来，我们可以用相应的平均价格来填充这些国家特定数据框中缺失的值:
for i in list(set(df['country'])):
df_country = df[df['country']== country]
df_country['price'].fillna(df_country['price'].mean(),inplace = True)
然后，我们将结果附加到一个我们称之为“帧”的列表中
frames = []
for i in list(set(df['country'])):
df_country = df[df['country']== country]
df_country['price'].fillna(df_country['price'].mean(),inplace = True)
frames.append(df_country)
最后，我们连接数据帧的结果列表:
frames = []
for i in list(set(df['country'])):
df_country = df[df['country']== i]
df_country['price'].fillna(df_country['price'].mean(),inplace = True)
frames.append(df_country)
final_df = pd.concat(frames)
现在，如果我们在估算前打印缺失价格值的数量，我们得到:
print(df.isnull().sum())
插补后:
print(final_df.isnull().sum())
我们看到除了一个缺失值之外，所有的值都被估算了。这对应于没有价格数据的埃及葡萄酒。我们可以通过检查 for 循环中数据帧的长度来解决这个问题，如果长度大于 1，则只使用特定于国家的平均值进行输入。如果长度等于 1，我们估算所有国家的平均值:
frames = []
for i in list(set(df['country'])):
df_country = df[df['country']== i]
if len(df_country) > 1:
df_country['price'].fillna(df_country['price'].mean(),inplace = True)
else:
df_country['price'].fillna(df['price'].mean(),inplace = True)
frames.append(df_country)
final_df = pd.concat(frames)
打印结果时，我们看到“价格”列的所有值都是估算的:
print(final_df.isnull().sum())
我们可以定义一个函数来概括这个逻辑。我们的函数将接受对应于数字列和分类列的变量:
def impute_numerical(categorical_column, numerical_column):
frames = []
for i in list(set(df[categorical_column])):
df_category = df[df[categorical_column]== i]
if len(df_category) > 1:
df_category[numerical_column].fillna(df_category[numerical_column].mean(),inplace = True)
else:
df_category[numerical_column].fillna(df[numerical_column].mean(),inplace = True)
frames.append(df_category)
final_df = pd.concat(frames)
return final_df
我们通过执行以下操作，使用我们的函数进行插补:
impute_price = impute_numerical('country', 'price')
print(impute_price.isnull().sum())
我们还要验证原始数据框和估算数据框的形状是否匹配
print("Original Shape: ", df.shape)
print("Imputed Shape: ", impute_price.shape)
类似地，我们可以定义一个估算分类值的函数。该函数将接受两个变量，这两个变量对应于具有分类值的列。
def impute_categorical(categorical_column1, categorical_column2):
cat_frames = []
for i in list(set(df[categorical_column1])):
df_category = df[df[categorical_column1]== i]
if len(df_category) > 1:
df_category[categorical_column2].fillna(df_category[categorical_column2].mode()[0],inplace = True)
else:
df_category[categorical_column2].fillna(df[categorical_column2].mode()[0],inplace = True)
cat_frames.append(df_category)
cat_df = pd.concat(cat_frames)
return cat_df
我们可以用各个国家/地区的模式来估算缺失的“taster_name”值:
impute_taster = impute_categorical('country', 'taster_name')
print(impute_taster.isnull().sum())
我们看到“taster_name”列现在没有缺失值。同样，让我们验证形状是否与原始数据框匹配:
print("Original Shape: ", df.shape)
print("Imputed Shape: ", impute_taster.shape)
我就讲到这里，但是您可以随意使用数据并自己编码。
结论
总之，在这篇文章中，我们讨论了如何使用 Pandas 库处理缺失值。首先，我们讨论了如何用数据的平均值来估算缺失的数值。然后，我们研究了如何进行特定类别的数值插补。最后，我们展示了如何用对应于另一个分类列的模式来估算缺失的分类值。我希望你觉得这篇文章有用/有趣。这篇文章中的代码可以在 GitHub 上找到。感谢您的阅读！
加快数据分析过程的熊猫技巧
用这些简单的技巧加速你的数据分析过程。
Pandas 是一个非常强大和通用的 Python 数据分析库，它加速了数据科学项目的预处理步骤。它提供了许多在数据分析中非常有用的函数和方法。
一如既往，我们从进口熊猫开始。
import numpy as np
import pandas as pd
让我们创建一个样本数据帧来处理。Pandas 是一个多功能库，通常提供多种方式来完成一项任务。因此，有许多方法可以创建数据帧。一种常见的方法是传递包含列作为键值对的字典。
values = np.random.randint(10, size=10)years = np.arange(2010,2020)groups = ['A','A','B','A','B','B','C','A','C','C']df = pd.DataFrame({'group':groups, 'year':years, 'value':values})df
我们还使用 numpy 创建数组，用作列中的值。 np.arange 返回指定区间内的范围值。 np.random.randint 根据指定的范围和大小返回随机整数值。
数据框架包含 3 个不同组的一些年值。我们可能只对每年的值感兴趣，但在某些情况下，我们也需要一个累计和。Pandas 提供了一个简单易用的函数来计算累计和，即 cumsum 。
df['cumsum'] = df['value'].cumsum()df
我们创建了一个名为“cumsum”的列，它包含值列中数字的累积和。但是，它不考虑群体。这种累积值在某些情况下可能没有用，因为我们无法区分不同的组。放心吧！这个问题有一个非常简单方便的解决方案。我们可以应用 groupby 函数。
df['cumsum'] = df[['value','group']].groupby('group').cumsum()df
我们首先对“组”列应用 groupby ，然后应用 cumsum 函数。现在，每组内的值相加。为了使数据框看起来更好，我们可能希望根据组而不是年份对值进行排序，这样我们可以直观地将组分开。
df.sort_values(by='group').reset_index()
我们应用了 sort_values 函数，并用 reset_index 函数重置索引。正如我们在返回的数据帧中看到的，原始索引作为一列保存。我们可以通过将 reset_index 函数的 drop 参数设置为 True 来消除。
df = df.sort_values(by='group').reset_index(drop=True)df
现在看起来好多了。当我们想在数据帧中添加一个新列时，默认情况下它会被添加到末尾。然而，pandas 提供了使用插入功能在任意位置添加新列的选项。
new = np.random.randint(5, size=10)df.insert(2, 'new_col', new)df
我们通过传递一个索引作为第一个参数来指定位置。该值必须是整数。列索引从零开始，就像行索引一样。第二个参数是列名，第三个参数是包含值的对象，这些值可以是系列或类似数组的对象。
假设我们想从数据帧中删除一列，但又想将该列保留为一个单独的序列。一种方法是将该列分配给一个系列，然后使用 drop 功能。更简单的方法是使用 pop 功能。
value = df.pop('value')df
通过一行代码，我们从 dataframe 中删除了 value 列，并将其存储在 pandas 系列中。
我们有时需要根据条件过滤数据帧或应用掩码来获得某些值。过滤数据帧的一个简单方法是查询函数。我将使用我们一直使用的样本数据框架。让我们首先将“值”列插回:
df.insert(2, 'value', value)df
使用查询函数非常简单，只需要条件。
df.query('value < new_col')
它返回“值”小于“新列”的行。我们可以设置更复杂的条件，也可以使用额外的操作符。
df.query('2*new_col > value')
我们还可以将多个条件组合成一个查询。
df.query('2*new_col > value & cumsum < 15')
我们可以使用许多聚合函数来计算列的基本统计信息，如平均值、总和、计数等。我们可以将这些函数中每一个应用于一个列。然而，在某些情况下，我们可能需要检查不止一种类型的统计数据。例如，在某些情况下，计数和平均值可能都很重要。pandas 没有单独应用函数，而是提供了 agg 函数来应用多个聚合函数。
df[['group','value']].groupby('group').agg(['mean','count'])
既看均值又看计数更有意义。我们可以很容易地检测出异常值，这些异常值具有极端的平均值，但观察次数非常少。
我认为熊猫的成功和流行来自于其多功能、强大且易于使用的操作和分析数据的功能。和熊猫一起完成一项任务几乎总是有多种方式。由于花在数据科学项目上的大部分时间都花在了数据清理和预处理步骤上，Pandas 是您武库中的宝贵资产。
感谢您的阅读。如果您有任何反馈，请告诉我。
Pandas vs SQL —与示例进行比较
如何使用这两者完成数据分析中的典型任务
Pandas 是一个用于数据分析和操作的 Python 库。SQL 是一种用于与数据库通信的编程语言。大多数关系数据库管理系统(RDBMS)使用 SQL 来操作存储在数据库中的表。它们的共同点是 Pandas 和 SQL 都操作表格数据(即表格由行和列组成)。
熊猫和 SQL 都是数据科学家和分析师的必备工具。当然，两者都有替代方案，但它们是这一领域的主导方案。
因为 Pandas 和 SQL 都是对表格数据进行操作的，所以类似的操作或查询都可以使用这两者来完成。在这篇文章中，我们将比较 Pandas 和 SQL 在数据分析过程中的典型操作。
我们将使用 Kaggle 上的客户流失数据集。
对于熊猫，我会用 Google Colab。将 csv 文件上传到 Colab 环境后，数据集被读入 pandas 数据帧。
import pandas as pd
churn = pd.read_csv("/content/churn.csv")
对于 SQL，我在 Amazon RDS 上创建了一个 MySQL 数据库，并使用 MySQL Workbench 将连接到它。建立连接后，我创建了一个名为“CHURN”的表，并将 csv 文件中的数据上传到该表中。您可以通过在 MySQL Workbench 中运行以下 SQL 语法来完成相同的操作。
CREATE TABLE CHURN (
RowNumber INT NOT NULL,
CustomerId INT NOT NULL,
Surname VARCHAR(20) NULL,
CreditScore INT NULL,
Geography VARCHAR(20) NULL,
Gender VARCHAR(20) NULL,
Age INT NULL,
Tenure INT NULL,
Balance DECIMAL(10,2) NULL,
NumOfProducts INT NULL,
HasCrCard INT NULL,
IsActiveMember INT NULL,
EstimatedSalary DECIMAL(10,2) NULL,
Exited INT NULL,
PRIMARY KEY(RowNumber)
);LOAD DATA LOCAL INFILE "C:/Users/soner/Desktop/SQL/churn.csv" INTO TABLE CHURN
FIELDS TERMINATED by ','
ENCLOSED by '"'
LINES TERMINATED by '\n' IGNORE 1 LINES;
注意:如果使用最新版本(8。)的话，上面的 load data 语句就不起作用了。我用的是 6 版。
我们现在有了一个客户流失数据框架和一个客户流失表。让我们从数据分析过程中常见的基本操作开始。
获取数据概述
这里概述的含义有点模糊。这里我指的是列及其数据类型的列表。
DESC 语句后跟表名将在 SQL 中完成这项工作。
DESC CHURN;
(图片由作者提供)
对于熊猫，“dtypes”方法将返回每一列的数据类型。我们还可以使用“columns”方法来查看列的列表。
churn.dtypes
(图片由作者提供)
显示前 5 行
这也可以被认为是获得数据的概述。数字 5 只是惯例，但是你可以改变它。
在 SQL 方面，我们将使用 SELECT 语句。
SELECT * FROM CHURN LIMIT 5;
(图片由作者提供)
我们选择了所有列(*)的前 5 行(限制为 5 行)。该屏幕截图仅包含 7 列，因此很适合屏幕。
不是每个 DBMS 都有相同的语法。我们这里用的是 MySQL。例如，SQL Server 使用 SELECT TOP 语句。
Pandas 为这个操作提供了一个更简单的语法。
churn.head(5) # The default is 5 so churn.head() also works
(图片由作者提供)
选择特定的列
对于 SQL，我们只需要用列名替换“*”。
SELECT CustomerId, Geography FROM CHURN;
(图片由作者提供)
对熊猫来说是这样做的。
churn[['CustomerId', 'Geography']]
(图片由作者提供)
选择符合条件的行
在分析数据时，我们可能会考虑一些条件。例如，在我们的数据集中，任务可能是基于一些测量来比较不同的国家。因此，能够有条件地选择数据点非常重要。
我们可以在 SQL 中使用 WHERE 语句。例如，以下查询将返回“地理位置”列中的值为“法国”的选定列。
SELECT CustomerId, Geography FROM CHURN
WHERE Geography = 'France'
LIMIT 5;
(图片由作者提供)
对于 Pandas，根据条件过滤数据帧，然后选择所需的列和行。
churn[churn.Geography == 'France'][['CustomerId','Geography']][:5]
(图片由作者提供)
列中的唯一值
分析分类列和数字列是很重要的。分类列的一个关键特征是唯一的类别。
让我们看看在地理位置一栏中有哪些国家。
SELECT DISTINCT 语句将返回表中的不同值。
SELECT DISTINCT Geography FROM CHURN;
(图片由作者提供)
同样的操作可以用熊猫特有的功能来完成。
churn.Geography.unique()
array(['France', 'Spain', 'Germany'], dtype=object)
列中唯一值的数量
在地理栏中，只有 3 个不同的国家，所以我们可以直观地计算。在某些情况下，独特类别的数量很大，所以我们需要一种方法来计算它们。
对于 SQL，我们可以如下使用 COUNT 语句:
SELECT COUNT(DISTINCT Geography) FROM CHURN;
3
对于熊猫，nunique 函数将完成这项工作。
churn.Geography.nunique()
3
每个类别中的行数
我们已经介绍了如何检查唯一类别和唯一类别的数量。更进一步，查看每个类别有多少数据点(即行数)可能更有用。
对于 SQL，可以使用 COUNT 和 GROUP BY 语句来完成，如以下查询所示:
SELECT Geography, COUNT(Geography) AS 'count'
FROM CHURN
GROUP BY Geography;
(图片由作者提供)
我们选择了两列，一列是 Geography，另一列是 Geography 列中的行数。如果末尾没有“GROUP BY”语句，查询将返回一行，指示表中的总行数。
熊猫的 value_counts 函数可以完成同样的任务。
churn.Geography.value_counts()
(图片由作者提供)
分组和聚合函数
SQL 和 Pandas 都允许对查询结果应用聚合函数，这对于高效的数据分析非常重要。
例如，我们可以检查不同国家客户的平均年龄。下面的 SQL 查询将完成这项任务，它还将根据平均年龄值对结果进行排序。
SELECT Geography, AVG(Age) AS 'Average Age'
FROM CHURN
GROUP BY Geography
ORDER BY Age;
(图片由作者提供)
熊猫遵循相同的想法，只是语法不同。
churn[['Geography','Age']].groupby('Geography').mean()\
.sort_values(by='Age', ascending=False)
(图片由作者提供)
结论
我们只介绍了 Pandas 或 SQL 的一小部分功能。然而，这些操作对于典型的数据分析过程是必不可少的。我认为它们是学习复杂操作所必须掌握的基础。
正如您在示例中看到的，Pandas 和 SQL 背后的逻辑非常相似。一旦你熟悉了其中的一种，学习另一种就相当容易了。这只是一个语法问题。
如果你正在从事或者打算从事数据科学领域的工作，我强烈推荐你学习熊猫和 SQL。
感谢您的阅读。如果您有任何反馈，请告诉我。
熊猫！！！第一次现场技术面试后我学到了什么
技术面试
关于熊猫 str 关键文本清洗技巧的思考
前言
我知道很多人在面试时会紧张。同样，在我的面试中，10 次有 8 次我会坐立不安。这意味着忘记我口袋里的常用技巧，或者错过一些我应该知道的关键知识。最近，我参加了一个商业智能实习职位的现场技术面试，你猜怎么着？全是:熊猫！虽然采访没有我想象的那么顺利，但我想把这次经历转变成对我认为对熊猫至关重要的事情的反思，特别是文本数据处理。
概观
本文将介绍在 Pandas 、**、**中处理文本数据的主要功能。Series.str "。大部分问题设置和我面试时经历的差不多。当你阅读这篇文章时，你将有机会回顾你所学到的东西，如果你期待一次技术面试，你将会收到一个友好的提醒。如果您是熊猫的新手，我希望您可以将本文中展示的技巧添加到您的数据科学工具包中。让我们开始朝着更加结构化的数据前进。
每当张彝伦出版的时候收到一封电子邮件。或者督促他多发表！！！通过注册，您将创建一个媒体…
medium.com](https://medium.com/subscribe/@yunglinchang) 
台北动物园的熊猫，来源:我
仅供参考:
- 这篇文章将被分成小的问题集和这些问题之后可能的解决方案(或者我用来解决每个问题的方法)。
- 这个数据集是一个虚构的“水果”公司的销售数据，用来说明你在面试、工作或数据项目中可能遇到的挑战。
“水果”公司的销售数据，来源:我
- 数据被预加载并保存在 df 中，并且不要忘记:
import pandas as pd
事不宜迟，我们开始吧！
首先，面试官给了你一份水果销售部门的数据集。你被要求用你的 Python 技术能力解决每一个专栏中的问题。你发现了什么？
Sales_ID:怪异的感叹号和多余的空格
如果我们看一下 Sales_ID 列的第一行，您会发现它包含不必要的空格和一个感叹号。这是一个问题，因为在 Sales_ID 列中我们不需要那些多余的字符。
df[ 'Sales_ID'][0]**Out: 'AU_1382578 !'**
我们能做的就是利用 **熊猫。**中的法熊猫！ strip() 修剪掉列的前导和尾随字符。还有类似于右条带的 rstrip() 和左条带的 lstrip() 的小变体。
当数据两边有不重要的字符和符号时，使用 strip() 非常有用。这里我们先去掉右边的“！”然后去掉两边的空格。
df['Sales_ID'] = df['Sales_ID']**.str.rstrip('!').str.strip()**
Sales_ID，来源:我
祝贺您清理了 Sales_ID 列！
Sales_Branch:缺失？一点特色工程
似乎 Sales_Branch 列完全丢失了！面试官让你用 Sales_ID 一栏的提示来搞定。快速检查后，您发现销售是根据 Sales_ID 的前两个单词分配给水果的各个分支的。
我们可以用 熊猫。series . str . slice方法对字符串的关键元素进行切片。例如:'AU _ 1382578’in Sales _ ID→【AU】in Sales _ Branch。
slice() 包含 3 个参数:
- ****开始:从哪里开始，默认值为 0
- ****停止:在哪里停止(不含)
- ****步:多远的一步，默认值为 1
df['Sales_Branch'] = df['Sales_ID']**.str.slice(stop=2)**
销售 _ 分公司，来源:我
祝贺 Sales_Branch 专栏的特色工程！
Product_Description:包含销售产品的详细描述
大概在大多数场合，公司的系统都会产生一个长句子的交易日志。但是这些句子包含了你的面试官想要的有价值的信息。
df['Product_Description'][0]**Out: 'The Fruit, a company that sells fruits from all over the world, has branches in Australia, the United Kingdom, the United States, and Taiwan. Product: Apple Mango Banana Watermelon Orange Blueberry Banana Watermelon Kiwifruit'**
我们可以看到，虽然所有的第一句都是相同的，但我们可以将其分为两列:描述和产品。这就是 熊猫。 方法进场。
split() 包含 3 个参数:
- pat: 默认情况下，使用空白分割什么
- 用户可以指定他们想要多少分割
- ****展开:当 expand=True 时，拆分被放入单独的列中
df['Product_Description']**.str.split(' Product: ', expand=True)**
来源:我
我们可以通过两种方式将 0 和 1 分配给描述和产品:
df['Description'] = df['Product_Description'].str.split(' Product: ', expand=True)[0]
df['Product'] = df['Product_Description'].str.split(' Product: ', expand=True)[1]
或者
df[['Description', 'Product']] = df['Product_Description'].str.split(': ', expand=True)
由 Unsplash 上的 Karoline Stk 拍摄的照片
现在，面试官变得挑剔了，增加了一个额外的要求:对产品列中的产品列表进行排序。
没必要感到焦虑！这可以通过首先用 split()拆分 Product 列中的值，然后在 Python 中应用排序的函数来实现。
df['Product'] = df['Product']**.str.split().apply(sorted)**
描述和产品，来源:我
祝贺您从 Product_Description 专栏中获得了信息！
Product_Count:每个销售人员的水果数量
采访者想了解他们的销售人员正在销售的各种水果。很高兴知道还可以用 熊猫。series . str . len方法获取产品列中列表的长度。
**df['Product_Count'] = df['Product']**.str.len()****
让我们来看看谁卖的水果品种最多！
**df[df['Product_Count'] == max(df['Product_Count'])]**
来源:我
卖 10 种不同水果的澳大利亚代表似乎是赢家！
恭喜你在产品计数栏中计算出了各种水果！
产品:不仅仅是产品列表
因此，在从 Product_Description 中获取产品之后，您面临着另一个挑战！面试官问你是否可以用两种方式拆分产品栏:
- 将列拆分为产品 1、产品 2、…
- 对每个产品进行一次性编码
汤姆·格伦鲍尔在 Unsplash 上的照片
1.将此列拆分为产品 n
利用 pd，我们可以轻松应对这一挑战。 系列，我们可以把它的产品列表变成pandas . core . frame . data frame。
**Products = df['Product']**.apply(pd.Series)** Products**
然后，我们通过重命名列名来完成我们的工作！
**Products = Products.rename(columns=lambda x: 'Product_'+str(x))
Products**
10 行× 9 列，来源:我
2.对每个产品进行一次性编码
熊猫中的一键编码称为 熊猫。Series.str.get_dummies
******get _ dummies()只有 1 个参数:
- sep: 要拆分的内容，默认值为’ | ’
我们使用拆分后的原始形式，因为我们可以使用空格来分隔它们。(填充自由以尝试使用带有循环的列表形式！)
***df['Product_Description'].str.split(': ', expand=True)[1]***
由空格分隔的产品，来源:Me
通过应用get _ dummies()，我们从操作中得到每个水果的 10 行× 27 列(那是巨大的！).****
***Products2 = df['Product_Description'].str.split(': ', expand=True)[1]**.str.get_dummies(' ')**
Products2***
10 行× 27 列，来源:我
在满足了这两个要求后，面试官最终决定选择选项 1 作为最终版本。我们可以将产品(选项 1)与原始数据框 df 合并，得到 10 行× 17 列的形状。
***df = **pd.concat([df, Products], axis=1)*****
仅供参考:
scikit-learn 库也提供了一个具有相同功能的“multilabel binary izer，不过那是后话了。
恭喜你将每种水果从产品栏中分离出来！
最近销售日期:年-月-日
我们几乎完成了我们的采访，最后一个任务是数据时间的职责。面试官要求您将“最近销售日期”列转换为“年-月-日”格式。这是为了进一步防止将来选择具有不同输出时间的日期的操作。
首先，我们裁剪出我们想要的日期，这可以通过两种方式实现:
***Dates = df['Recent_Sales_Date']**.str[:10]*****
或者
***Dates = df['Recent_Sales_Date']**.str.slice(stop=10)*****
Mille Sanders 在 Unsplash 上拍摄的照片
第二，简单的把它包在PD . to _ datetime()里面。
***df['Recent_Sales_Date'] = **pd.to_datetime(Dates)*****
最近 _ 销售 _ 日期，来源:我
恭喜您重新格式化了最近销售日期列中的日期时间！
收场白
面试过程正式结束！恭喜你。我希望这篇文章能给你提供我第一次技术面试的经历。虽然这次我做得不好，但这也不会是最后一次！现在，我们对熊猫的文本数据操作更有信心了。感谢大家的参与！
简单回顾一下， strip() ， slice() ， split() 方法都是处理文本数据时的有用工具:您可以选择剥离两边不相关的部分，切片可以使用的必要部分，并根据拆分标准划分数据。
这里是文章中所有代码的 Github repo！
每当张彝伦出版的时候收到一封电子邮件。或者督促他多发表！！！通过注册，您将创建一个媒体…
medium.com](https://medium.com/subscribe/@yunglinchang)
我喜欢学习数据，并思考(写下)我在实际应用中所学到的东西。如果你有更多需要讨论的，你可以通过 LinkedIn 和 Twitter 联系我。此外，请随时关注我的 Medium，以获取更多数据科学文章！
来数据科学游乐场一起玩吧！*****
熊猫与 Dask，一个超快的笔记本电脑
礼貌: Pixabay
如果你进入数据世界，那么使用熊猫的需求可能会非常频繁。嗯，我们都知道一件事，熊猫是惊人的，更像是数据世界的福音。我们大多数人至少花几分钟甚至几个小时使用熊猫进行数据处理和日常分析。熊猫不需要太多的介绍，但这里有几件事你应该知道:
熊猫非常适合许多不同种类的数据:
- 具有不同类型列的表格数据，如在 SQL 表或 Excel 电子表格中
- 有序和无序(不一定是固定频率)时间序列数据。
- 带有行和列标签的任意矩阵数据(同类或异类)
- 任何其他形式的观察/统计数据集。数据根本不需要被标记就可以放入 pandas 数据结构中。
使用具有千兆字节或兆兆字节数据的熊猫更像是笔记本中的一种痛苦:d .我经常使用千兆字节的文件，笔记本就像*“等一下，让我现在冻结！”*。顺便说一下，我的系统有一些惊人的配置。使用熊猫无法处理海量数据，因此这就是我们必须开始使用 dask 的地方。在这篇文章中，我将演示如何使用 dask 和 pandas 来加速你的笔记本。在 dask 中，读取 GB 的文件只需要几秒钟。在开始演示之前，让我简单介绍一下 dask。
达斯克:
Dask 有 3 个并行集合，即数据帧、包和数组。这使得它能够存储比 RAM 更大的数据。其中的每一个都可以使用在 RAM 和硬盘之间分区的数据，也可以分布在集群中的多个节点上。Dask 数据帧是按行划分的，按索引值对行进行分组以提高效率。这些熊猫对象可能存在于磁盘或其他机器上。Dask 数据框架协调许多熊猫数据框架或沿索引排列的系列
Dask 可以利用多核 CPU 在单台机器上实现高效的并行计算，并从磁盘高效地传输数据。它可以在分布式集群上运行。Dask 还允许用户用单机调度程序替换集群，这将降低开销。这些调度程序不需要设置，可以完全在与用户会话相同的进程中运行。关于 dask 的其他一些事情:
- 并行处理 NumPy 数组和 Pandas DataFrame 对象的能力
- 与其他项目的集成。
- 分布式计算
- 更快的操作，因为它的低开销和最少的序列化
- 在具有数千个内核的集群上弹性运行
- 实时反馈和诊断
演示:
用于演示的完整代码可以在我的 Github repo 中找到，您可以在本文末尾找到链接。现在，让我们开始演示:
导入库:
计算运行时间和文件大小的代码:
第一个代码片段是计算我们在这里执行的操作所用的时间，例如:读取文件。在第二个片段中，我们显示了我们将在这个演示中使用的文件大小。文件大小约为 4GB。
首先，我们将看到一些东西 Dask
更擅长的事情，然后我们将跳到熊猫做得更好的事情。这将帮助您结合这两个库并执行您的分析。
关于熊猫的讨论:
读取文件—熊猫& Dask:
熊猫花了大约 5 分钟来读取一个 4gb 大小的文件。等等，大小并不代表一切，数据集中的列数和行数在时间消耗中起着重要作用。让我们看看 Dask 处理同一个文件需要多少时间。
天啊，读同一个文件只花了大约 2 毫秒，而熊猫花了大约 5 分钟。是不是太神奇了？让我们对 pandas 数据帧和 dask 数据帧执行更多的操作。
追加两个文件—熊猫& Dask:
为了执行这个操作，我们将读取另一个文件，然后将它附加到前一个文件中。
执行上述操作大约需要 9 分钟。现在让我们看看如何使用 Dask 来优化它。
好吧，好吧，你又节省了 9 分钟。现在让我们看看其他常用的熊猫。
数据分组—熊猫& Dask:
熊猫花了 6 分多钟做了一个简单的分组。让我们看看 dask 还能节省多少时间。
哇，你又节省了 6 分钟的欢呼时间。如果你使用 dask，还有许多其他的事情可以节省你更多的时间。
合并数据集—熊猫& Dask:
事情是这样的。它尝试了 30 分钟，仍然无法用熊猫合并这两个文件。看看用 dask 能不能做到。
嗯，我用 dask 只花了一秒钟就搞定了。与在推断数据类型之前读入整个文件的pandas.read_csv不同的是，dask.dataframe.read_csv只从文件的开头读入一个样本(如果使用 glob，则从第一个文件开始)。然后，在读取所有分区时，会强制使用这些推断的数据类型。
达斯克上空的熊猫:
分拣——熊猫& Dask:
我尝试根据列中的值对数据框进行排序，这花了我大约一分半钟的时间，相当不错。让我们看看 dask 如何帮助我们。
不幸的是，dask 甚至不能启动这个任务，因为 dask 没有排序功能，尽管它使用了 pandas API。熊猫万岁！
独特的¬NA——熊猫& Dask:
完成这些任务只需要大约 1 分钟。熊猫把大多数事情都做得很好，但也有一些事情做得不好。
Dask 也不支持这两件事。有许多其他的事情你会用到熊猫。
将数据帧保存到文件—熊猫& Dask:
熊猫在保存文件方面做得很好。我花了大约 3 分钟保存过滤后的文件。
Dask 没有正确保存文件。它将文件分成多个块，并将这些文件保存在一个具有上述名称的文件夹中。另一个问题是你再也不能读取这个保存的文件了。这只是浪费时间。
将 dask 数据框保存到文件的解决方案是将其转换为类似这样的 pandas 数据框，然后将 pandas 数据框保存到文件。
结论:
熊猫和达克一起使用总是最好的选择，因为一方可以很好地弥补另一方的不足。当单独使用时，我想你可能会遇到不同的问题。因此，我们得出结论，与 Dask 熊猫可以节省你很多时间和资源。
注意:
Dask 更快，因为在我们使用。计算()。虽然，这可以节省很多，很多时间，给我们更多的速度！
提示:
# Use this to make pandas run faster
pd.read_csv(filepath, engine = 'c')
如果你知道任何比 dask 更好的选择，请告诉我。
Jupyter 笔记本(使用代码):https://github . com/kunaldhariwal/Medium-12-Amazing-Pandas-NumPy-Functions
我希望这有助于你增强你的知识基础:)
更多信息请关注我！
顺便说一句，你知道吗，你还可以在土星云 上免费使用 Dask 和 pandas，点击这里 ，一个云中可扩展的数据科学环境。团队可以利用强大的资源、工作、部署等进行协作。
感谢您的阅读和宝贵时间！
熊猫从零到英雄——使用熊猫的初学者教程
熊猫零到英雄是一个视频教程系列，旨在教初学者友好的方式使用熊猫
在我开始无耻的宣传之前，我想先分享一下我对熊猫的发现，为什么它在数据科学界如此受欢迎，以及我开始这个视频系列的动机。
今年年初，我踏上了自学数据科学的旅程。在筛选了无限量的在线资源后，有一个平台我经常发现自己又回到了那里。这也是我开始旅程的地方，那就是卡格尔。
Kaggle 是谷歌的子公司，是一个由来自世界各地的数据科学家和机器学习实践者组成的在线社区。在这里，你可以找到迷你课程、已发布的数据集，但最重要的是，人们竞争解决各种类型的数据科学和机器学习挑战的比赛。
Kaggle 最初吸引我的是其他人从过去的比赛中分享的笔记本。作为一个从实际项目中学到很多东西的人，我很感激我可以参考这些笔记本来学习解决数据科学问题的传统方法。
最早引起我注意的事情之一是熊猫图书馆。我突然想到，在我翻阅的所有笔记本中，每个人都在使用它。
尽管当时我不知道熊猫是什么，但我能够很快掌握大多数正在使用的功能。请注意，那时我对数据科学完全陌生。这突出了这种数据分析工具的优雅性、健壮性和直观性。
熊猫是什么？
Pandas 是一个建立在 Python 编程语言之上的数据操作库。
Pandas 具有内置功能，几乎可以处理任何你想处理的数据，例如选择特定的列或行，处理缺失的数据，分组和排序，合并不同的数据框等等。
为什么你应该学习熊猫
如果您经常处理数据，或者如果您是一个认真学习数据科学的初学者，Pandas 是您的工具包中绝对应该拥有的最重要的工具之一。
任何数据科学或机器学习项目的一个关键要素是能够有效地操作和评估数据的内容。Pandas 不仅提供了一种灵活的方式来管理您的数据框架，更重要的是，它允许您清楚地分析数据本身的潜在模式。如果你想把你的数据分析技能提升到一个新的水平，这是一个强大的工具。
额外收获如果你已经熟悉了 Python 语法，你很快就能学会熊猫。但是，如果您是 Python 新手，请不要担心，学习起来一点也不难！
为什么我开始熊猫零到英雄？
我创办《熊猫零到英雄》主要有两个原因，一个是为了自己，一个是为了世界。
- 我想做这个教程不仅是为了加强我个人对熊猫的了解，也是为了提高我的沟通技巧和在镜头前自信地说话的能力。
- 我想激励和鼓励更多的人将熊猫纳入他们的数据分析工作。熊猫的投资回报率非常高，这意味着你只要学会几个基本功能，就可以立即投入工作。所有的好处与非常少的时间成本，这是一个显而易见的学习，特别是对初学者。
熊猫零到英雄的内容
受 MCU(漫威电影宇宙)中的六个无限宝石的启发，熊猫零到英雄包含六个独立的教程视频，每个视频涵盖了不同的熊猫概念。一旦掌握，它们将赋予你掌控宇宙的巨大力量——数据科学宇宙。
第 1 周:创建自己的数据框
在本教程中，我们将学习如何将 Pandas 库导入到我们的笔记本中，以及如何读取外部数据集。最常见的文件格式，至少在 Kaggle 上，被称为逗号分隔值或简称 CSV。Pandas 的功能允许你读取不同格式的数据集，包括 CSV。
除了导入和读取外部数据集，我们还将学习如何创建自己的虚拟数据框。
第 2 周:选择数据
数据框由行和列组成，行代表观察值，列代表这些观察值的要素。例如，在房价数据集中，行数对应于数据集中房屋的数量。另一方面，列将包含那些决定其最终销售价格的房屋的各种特征，如卧室数量、地块面积、与主要道路的接近程度等。
选择数据是数据科学家最基本的技能之一。它允许您仔细检查数据的子集，并对满足特定条件的特定行和列应用函数。
在本教程中，我们将学习如何使用 Pandas 中的 loc 和 iloc 函数选择数据。
第三周:功能
函数是我们在一组一个或多个输入上实现的变换或计算。换句话说，一个函数将接受一个输入，以预先指定的方式处理它，并在最后返回一个输出。
Pandas 本身已经内置了许多函数，但是如果我们想要创建自己独特的数据转换，我们可以先写出我们的函数，然后将其应用于我们的数据。
在本教程中，我们将学习一些描述性统计的基本函数，如何执行和应用 Python 函数，以及将文本变量转化为数值的编码概念。
第 4 周:分组和排序数据
分割是一种强大的方法，不仅可以将大问题分解成更小的组成部分，还可以让我们更准确地观察和分析数据中发生的趋势，从而获得更好的见解。
我们看到分段正被用于涉及问题解决的各种领域，数据科学也不例外。有许多方法可以对数据进行分组和排序。一些例子包括按客户年龄组、产品类别、地理区域等进行细分。
在本教程中，我们将学习如何根据某些特征对数据进行分组和排序。
第 5 周:处理缺失数据
缺失数据或空值是您在数据科学之旅中最常遇到的问题之一，也是一个需要正确解决以提高模型准确性的问题。
在本教程中，我们将介绍处理缺失数据的两种方法，并讨论它们之间的权衡。
最简单直接的方法是删除包含缺失数据的行或列。然而，在这样做的时候，我们会面临从数据框架中移除潜在有用信息的风险，这将对我们的模型做出准确预测的能力产生不利影响。
或者，我们可以用一些替代值来估算或替换那些缺失的数据。尽管这种方法更可取，但这一过程通常需要更多的时间、考虑和经验。
第 6 周:组合数据框架
通常，在数据科学项目中，您将使用多个数据集。因此，有时您可能需要将不同的数据框合并在一起，以使您的分析更加顺畅。
在本教程中，我们将学习 concat 和 merge，这是 Pandas 中的两个功能，允许您以灵活的方式组合数据框。
结论
这六个教程视频是速成课程，将为您提供关于如何使用熊猫图书馆的基础知识。
然而，您必须在实际的数据科学项目中尽可能多地练习使用它，以完全掌握这些视频背后的概念。换句话说，把它们当作简短的介绍性视频来帮助你开始，但是继续把它们应用到一个实际的项目设置中来最大化你的学习。
说到这里，祝你学习愉快，希望在我的下一篇文章中见到你。与此同时，请随时关注我的 YouTube 和 T2 GitHub。
感谢阅读！
扫一扫
724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
