1、Categorical类型
默认情况下，具有有限数量选项的列都会被分配object 类型。 但是就内存来说并不是一个有效的选择。 我们可以这些列建立索引，并仅使用对对象的引用而实际值。Pandas 提供了一种称为 Categorical的Dtype来解决这个问题。
例如一个带有图片路径的大型数据集组成。 每行有三列：anchor, positive, and negative.。
如果类别列使用 Categorical 可以显着减少内存使用量。
# raw data
+----------+------------------------+
| class | filename |
+----------+------------------------+
| Bathroom | Bathroom\bath_1.jpg |
| Bathroom | Bathroom\bath_100.jpg |
| Bathroom | Bathroom\bath_1003.jpg |
| Bathroom | Bathroom\bath_1004.jpg |
| Bathroom | Bathroom\bath_1005.jpg |
+----------+------------------------+
# target
+------------------------+------------------------+----------------------------+
| anchor | positive | negative |
+------------------------+------------------------+----------------------------+
| Bathroom\bath_1.jpg | Bathroom\bath_100.jpg | Dinning\din_540.jpg |
| Bathroom\bath_100.jpg | Bathroom\bath_1003.jpg | Dinning\din_1593.jpg |
| Bathroom\bath_1003.jpg | Bathroom\bath_1004.jpg | Bedroom\bed_329.jpg |
| Bathroom\bath_1004.jpg | Bathroom\bath_1005.jpg | Livingroom\living_1030.jpg |
| Bathroom\bath_1005.jpg | Bathroom\bath_1007.jpg | Bedroom\bed_1240.jpg |
+------------------------+------------------------+----------------------------+
filename列的值会经常被复制重复。因此，所以通过使用Categorical可以极大的减少内存使用量。
让我们读取目标数据集，看看内存的差异：
triplets.info(memory_usage="deep")
# Column Non-Null Count Dtype
# --- ------ -------------- -----
# 0 anchor 525000 non-null category
# 1 positive 525000 non-null category
# 2 negative 525000 non-null category
# dtypes: category(3)
# memory usage: 4.6 MB
# without categories
triplets_raw.info(memory_usage="deep")
# Column Non-Null Count Dtype
# --- ------ -------------- -----
# 0 anchor 525000 non-null object
# 1 positive 525000 non-null object
# 2 negative 525000 non-null object
# dtypes: object(3)
# memory usage: 118.1 MB
差异非常大，并且随着重复次数的增加，差异呈非线性增长。
2、行列转换
sql中经常会遇到行列转换的问题，Pandas有时候也需要，让我们看看来自Kaggle比赛的数据集。census_start .csv文件:
可以看到，这些按年来保存的，如果有一个列year和pct_bb，并且每一行有相应的值，则会好得多，对吧。
cols = sorted([col for col in original_df.columns \
if col.startswith("pct_bb")])
df = original_df[(["cfips"] + cols)]
df = df.melt(id_vars="cfips",
value_vars=cols,
var_name="year",
value_name="feature").sort_values(by=["cfips", "year"])
看看结果，这样是不是就好很多了：
3、apply()很慢
我们上次已经介绍过，最好不要使用这个方法，因为它遍历每行并调用指定的方法。但是要是我们没有别的选择，那还有没有办法提高速度呢？
可以使用swifter或pandarallew这样的包，使过程并行化。
Swifter
import pandas as pd
import swifter
def target_function(row):
return row * 10
def traditional_way(data):
data['out'] = data['in'].apply(target_function)
def swifter_way(data):
data['out'] = data['in'].swifter.apply(target_function)
Pandarallel
import pandas as pd
from pandarallel import pandarallel
def target_function(row):
return row * 10
def traditional_way(data):
data['out'] = data['in'].apply(target_function)
def pandarallel_way(data):
pandarallel.initialize()
data['out'] = data['in'].parallel_apply(target_function)
通过多线程，可以提高计算的速度，当然当然，如果有集群，那么最好使用dask或pyspark
4、空值，int, Int64
标准整型数据类型不支持空值，所以会自动转换为浮点数。所以如果数据要求在整数字段中使用空值，请考虑使用Int64数据类型，因为它会使用pandas.NA来表示空值。
5、Csv, 压缩还是parquet?
尽可能选择parquet。parquet会保留数据类型，在读取数据时就不需要指定dtypes。parquet文件默认已经使用了snappy进行压缩，所以占用的磁盘空间小。下面可以看看几个的对比
| file | size |
+------------------------+---------+
| triplets_525k.csv | 38.4 MB |
| triplets_525k.csv.gzip | 4.3 MB |
| triplets_525k.csv.zip | 4.5 MB |
| triplets_525k.parquet | 1.9 MB |
+------------------------+---------+
读取parquet需要额外的包，比如pyarrow或fastparquet。chatgpt说pyarrow比fastparquet要快，但是我在小数据集上测试时fastparquet比pyarrow要快，但是这里建议使用pyarrow，因为pandas 2.0也是默认的使用这个。
6、value_counts ()
计算相对频率，包括获得绝对值、计数和除以总数是很复杂的，但是使用value_counts，可以更容易地完成这项任务，并且该方法提供了包含或排除空值的选项。
df = pd.DataFrame({"a": [1, 2, None], "b": [4., 5.1, 14.02]})
df["a"] = df["a"].astype("Int64")
print(df.info())
print(df["a"].value_counts(normalize=True, dropna=False),
df["a"].value_counts(normalize=True, dropna=True), sep="\n\n")
这样是不是就简单很多了
7、Modin
注意：Modin现在还在测试阶段。
pandas是单线程的，但Modin可以通过缩放pandas来加快工作流程，它在较大的数据集上工作得特别好，因为在这些数据集上，pandas会变得非常缓慢或内存占用过大导致OOM。
!pip install modin[all]
import modin.pandas as pd
df = pd.read_csv("my_dataset.csv")
以下是modin官网的架构图，有兴趣的研究把：
8、extract()
如果经常遇到复杂的半结构化的数据，并且需要从中分离出单独的列，那么可以使用这个方法：
import pandas as pd
regex = (r'(?P[A-Za-z\'\s]+),'
r'(?P
[A-Za-z\s\']+),'
r'(?P
[\d-]+),'
r'(?P
\d),'
r'(?P
.+)')
addr = pd.Series([
"The Lost City of Amara,Olivia Garcia,978-1-234567-89-0,2023,HarperCollins",
"The Alchemist's Daughter,Maxwell Greene,978-0-987654-32-1,2022,Penguin Random House",
"The Last Voyage of the HMS Endeavour,Jessica Kim,978-5-432109-87-6,2021,Simon & Schuster",
"The Ghosts of Summer House,Isabella Lee,978-3-456789-12-3,2000,Macmillan Publishers",
"The Secret of the Blackthorn Manor,Emma Chen,978-9-876543-21-0,2023,Random House Children's Books"
addr.str.extract(regex)
9、读写剪贴板
这个技巧有人一次也用不到，但是有人可能就是需要，比如：在分析中包含PDF文件中的表格时。通常的方法是复制数据，粘贴到Excel中，导出到csv文件中，然后导入Pandas。但是，这里有一个更简单的解决方案:pd.read_clipboard()。我们所需要做的就是复制所需的数据并执行一个方法。
有读就可以写，所以还可以使用to_clipboard()方法导出到剪贴板。
但是要记住，这里的剪贴板是你运行python/jupyter主机的剪切板，并不可能跨主机粘贴，一定不要搞混了。
10、数组列分成多列
假设我们有这样一个数据集，这是一个相当典型的情况:
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3],
"b": [4, 5, 6],
"category": [["foo", "bar"], ["foo"], ["qux"]]})
# let's increase the number of rows in a dataframe
df = pd.concat([df]*10000, ignore_index=True)
我们想将category分成多列显示，例如下面的
先看看最慢的apply：
def dummies_series_apply(df):
return df.join(df['category'].apply(pd.Series) \
.stack() \
.str.get_dummies() \
.groupby(level=0) \
.sum()) \
.drop("category", axis=1)
%timeit dummies_series_apply(df.copy())
#5.96 s ± 66.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
sklearn的MultiLabelBinarizer
from sklearn.preprocessing import MultiLabelBinarizer
def sklearn_mlb(df):
mlb = MultiLabelBinarizer()
return df.join(pd.DataFrame(mlb.fit_transform(df['category']), columns=mlb.classes_)) \
.drop("category", axis=1)
%timeit sklearn_mlb(df.copy())
#35.1 ms ± 1.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
是不是快了很多，我们还可以使用一般的向量化操作对其求和：
def dummies_vectorized(df):
return pd.get_dummies(df.explode("category"), prefix="cat") \
.groupby(["a", "b"]) \
.sum() \
.reset_index()
%timeit dummies_vectorized(df.copy())
#29.3 ms ± 1.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
使用第一个方法(在StackOverflow上的回答中非常常见)会给出一个非常慢的结果。而其他两个优化的方法的时间是非常快速的。
我希望每个人都能从这些技巧中学到一些新的东西。重要的是要记住尽可能使用向量化操作而不是apply()。此外，除了csv之外，还有其他有趣的存储数据集的方法。不要忘记使用分类数据类型，它可以节省大量内存。感谢阅读!
作者：Dmytro Samchuk
