相关疑难解决方法(0)

我在python pandas DataFrame中有一个列具有布尔值True/False值,但是为了进一步计算,我需要1/0表示.有快速的熊猫/ numpy方式吗？

编辑:下面的答案似乎没有在numpy的情况下,给定一个具有整数和True/False值的dtype=object数组,返回此类数组.为了在numpy中进行进一步的计算,我必须明确地设置np_values = np.array(df.values, dtype = np.float64).

我有一个pandas数据帧df,如下图所示:

BrandName Specialty
A          H
B          I
ABC        J
D          K
AB         L

我想用A替换BrandName列中的'ABC'和'AB'.有人可以帮忙吗？

我想在数据框中添加一个列'D',如下所示:

U,L
111,en
112,en
112,es
113,es
113,ja
113,zh
114,es

基于以下词典:

d = {112: 'en', 113: 'es', 114: 'es', 111: 'en'}

以便生成的数据框显示为:

U,L,D
111,en,en
112,en,en
112,es,en
113,es,es
113,ja,es
113,zh,es
114,es,es

到目前为止,我尝试了该pd.join()方法,但我无法弄清楚它如何与字典一起使用.

我正在尝试做一些在熊猫中应该非常简单的事情,但它似乎不过了.我正在尝试将列添加到现有的pandas数据帧,该数据帧是基于另一个(现有)列的映射值.这是一个小测试用例:

import pandas as pd
equiv = {7001:1, 8001:2, 9001:3}
df = pd.DataFrame( {"A": [7001, 8001, 9001]} )
df["B"] = equiv(df["A"])
print(df)

我希望以下结果:

      A   B
0  7001   1
1  8001   2
2  9001   3

相反,我得到一个错误告诉我,equiv不是一个可调用的函数.很公平,它是一本字典,但即使我将它包装在一个函数中,我仍然会感到沮丧.所以我尝试使用似乎与其他操作一起使用的map函数,但它也被使用字典击败了:

df["B"] = df["A"].map(lambda x:equiv[x])

在这种情况下,我只得到KeyError:8001.我已经阅读了文档和以前的帖子,但还没有发现任何暗示如何将字典与pandas数据帧混合的内容.任何建议将不胜感激.

我想使用将旧代码映射到新代码的字典替换数据框列中的某些值.

di = dict( { "myVar": {11:0, 204:11} } )
mydata.replace( to_replace = di, inplace = True )

但是一些新代码和旧代码重叠.当使用数据帧的.replace方法时,我遇到错误'Replacement not allowed with overlapping keys and values'

我目前的解决方法是手动替换替换违规密钥,然后将字典应用于剩余的非重叠案例.

mydata.loc[ mydata.myVar == 11, "myVar" ] = 0 
di = dict( { "myVar": {204:11} } )
mydata.replace( to_replace = di, inplace = True )

有更紧凑的方法吗？

如何s通过字典替换Pandas系列中的值d已被多次询问和重新询问.

推荐的方法(1,2,3,4)是要么使用s.replace(d),有时也使用s.map(d)如果所有的系列值是在字典键找到.

但是,使用性能s.replace通常非常慢,通常比简单的列表理解慢5-10倍.

替代方案,s.map(d)具有良好的性能,但仅在词典中找到所有键时才建议使用.

为什么s.replace这么慢,如何提高性能？

import pandas as pd, numpy as np

df = pd.DataFrame({'A': np.random.randint(0, 1000, 1000000)})
lst = df['A'].values.tolist()

##### TEST 1 #####

d = {i: i+1 for i in range(1000)}

%timeit df['A'].replace(d)                          # 1.98s
%timeit [d[i] for i in lst]                         # 134ms

##### TEST 2 #####

d = {i: i+1 for i in range(10)}

%timeit …

在实施机器学习模型之前，我正在预处理我的数据。某些特征具有高基数，例如国家/地区和语言。

由于将这些特征编码为 one-hot-vector 可以产生稀疏数据，我决定研究散列技巧并使用 python 的 category_encoders 像这样：

from category_encoders.hashing import HashingEncoder
ce_hash = HashingEncoder(cols = ['country'])
encoded = ce_hash.fit_transform(df.country)
encoded['country'] = df.country
encoded.head()

查看结果时，我可以看到碰撞

    col_0  col_1  col_2  col_3  col_4  col_5  col_6  col_7 country
0       0      0      1      0      0      0      0      0      US <??
1       0      1      0      0      0      0      0      0      CA.  ? US and SE collides 
2       0      0      1      0      0      0      0      0      SE <??
3       0      0      0      0      0      0 …

我有一个数据框：

   lft rel rgt num
0   t3  r3  z2  3
1   t1  r3  x1  9
2   x2  r3  t2  8
3   x4  r1  t2  4
4   t1  r1  z3  1
5   x1  r1  t2  2
6   x2  r2  t4  4
7   z3  r2  t4  5
8   t4  r3  x3  4
9   z1  r2  t3  4

以及参考词典：

replacement_dict = {
    'X1' : ['x1', 'x2', 'x3', 'x4'],
    'Y1' : ['y1', 'y2'],
    'Z1' : ['z1', 'z2', 'z3']
}

我的目标是将所有出现的 'X1' 替换replacement_dict['X1']，然后计算行的分组总和 …

假设我们有一个如下所示的 df ：

df = pd.DataFrame({'A': [3, 9, 3, 4], 'B': [7, 1, 6, 0], 'C': [9, 0, 3, 4], 'D': [1, 8, 0, 0]})

开始 df:

   A  B  C  D
0  3  7  9  1
1  9  1  0  8
2  3  6  3  0
3  4  0  4  0

如果我们想为 A 列分配新值，我希望以下内容能够工作：

d = {0:10,1:20,2:30,3:40}

df.loc[:,'A'] = d

输出：

   A  B  C  D
0  0  7  9  1
1  1  1  0  8
2  2  6  3  0 …

请帮助我理解为什么Python/Pandas中的"替换字典"操作很慢:

# Series has 200 rows and 1 column
# Dictionary has 11269 key-value pairs
series.replace(dictionary, inplace=True)

字典查找应为O(1).替换列中的值应为O(1).这不是矢量化操作吗？即使它没有矢量化,迭代200行只有200次迭代,那么它怎么会变慢呢？

以下是SSCCE演示此问题:

import pandas as pd
import random

# Initialize dummy data
dictionary = {}
orig = []
for x in range(11270):
    dictionary[x] = 'Some string ' + str(x)
for x in range(200):
    orig.append(random.randint(1, 11269))
series = pd.Series(orig)

# The actual operation we care about
print('Starting...')
series.replace(dictionary, inplace=True)
print('Done.')

在我的机器上运行该命令需要1秒以上的时间,这比执行<1000次操作的时间长1000倍.