Python 在两个数据之间保持相同的因式分解

我们有两个数据集，其中一个变量为col1。 第二个数据中缺少一些级别。比如让

import pandas as pd
df1 = pd.DataFrame({'col1':["A","A","B","C","D","E"]})
df2 = pd.DataFrame({'col1':["A","B","D","E"]})

当我们分解df1时

df1["f_col1"]= pd.factorize(df1.col1)[0]
df1

我们有

    col1    f_col1
0   A   0
1   A   0
2   B   1
3   C   2
4   D   3
5   E   4

但是当我们为df2做这件事的时候

df2["f_col1"]= pd.factorize(df2.col1)[0]
df2

我们有

    col1    f_col1
0   A   0
1   B   1
2   D   2
3   E   3

这不是我想要的。我想在数据之间保持相同的因式分解，也就是说，在df2中，我们应该有

    col1    f_col1
0   A   0
1   B   1
2   D   3
3   E   4

谢谢

---

PS：这两个数据集并不总是在同一时间可用，所以我无法将它们合并。值应以df1的形式存储，并在df2可用时使用。

您可以通过在

df.col1

上设置索引，重用

df1

的

f_col1

列和

map

值

In [265]: df2.col1.map(df1.set_index('col1').f_col1)
Out[265]:
0    0
1    1
2    3
3    4

细节

In [266]: df2['f_col1'] = df2.col1.map(df1.set_index('col1').f_col1)

In [267]: df2
Out[267]:
  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

如果

df1

有多条记录，请使用

drop\u duplicates

In [290]: df1
Out[290]:
  col1  f_col1
0    A       0
1    A       0
2    B       1
3    C       2
4    D       3
5    E       4

In [291]: df2.col1.map(df1.drop_duplicates().set_index('col1').f_col1)
Out[291]:
0    0
1    1
2    3
3    4
Name: col1, dtype: int32

---

通过在

df.col1

In [265]: df2.col1.map(df1.set_index('col1').f_col1)
Out[265]:
0    0
1    1
2    3
3    4

细节

In [266]: df2['f_col1'] = df2.col1.map(df1.set_index('col1').f_col1)

In [267]: df2
Out[267]:
  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

如果

df1

有多条记录，请使用

drop\u duplicates

In [290]: df1
Out[290]:
  col1  f_col1
0    A       0
1    A       0
2    B       1
3    C       2
4    D       3
5    E       4

In [291]: df2.col1.map(df1.drop_duplicates().set_index('col1').f_col1)
Out[291]:
0    0
1    1
2    3
3    4
Name: col1, dtype: int32

---

您可以连接两个数据帧，然后对整个列应用

pd.factorize

一次：

import pandas as pd
df1 = pd.DataFrame({'col1':["A","B","C","D","E"]})
df2 = pd.DataFrame({'col1':["A","B","D","E"]})

df = pd.concat({'df1':df1, 'df2':df2})
df['f_col1'], uniques = pd.factorize(df['col1'])
print(df)

屈服

      col1  f_col1
df1 0    A       0
    1    B       1
    2    C       2
    3    D       3
    4    E       4
df2 0    A       0
    1    B       1
    2    D       3
    3    E       4

  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

---

要从

df

提取

df1

和

df2

，可以使用

df.loc

：

In [116]: df.loc['df1']
Out[116]: 
  col1  f_col1
0    A       0
1    B       1
2    C       2
3    D       3
4    E       4

In [117]: df.loc['df2']
Out[117]: 
  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

（但请注意，如果可以将向量化操作应用于大数据帧一次而不是多次应用于较小的数据帧，则向量化操作的性能会有所提高，因此最好保持

df

并删除

df1

和

df2

。）

---

或者，如果必须先生成

df1['f_col1']

，然后计算

df2['f_col1']

以后，您可以使用

merge

在

col1

上加入

df1

和

df2

：

import pandas as pd
df1 = pd.DataFrame({'col1':["A","B","C","D","E"]})
df2 = pd.DataFrame({'col1':["A","B","D","E"]})

df1['f_col1'], uniques = pd.factorize(df1['col1'])
df2 = pd.merge(df2, df1, how='left')
print(df2)

屈服

      col1  f_col1
df1 0    A       0
    1    B       1
    2    C       2
    3    D       3
    4    E       4
df2 0    A       0
    1    B       1
    2    D       3
    3    E       4

  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

---

您可以连接两个数据帧，然后对整个列应用

pd.factorize

一次：

import pandas as pd
df1 = pd.DataFrame({'col1':["A","B","C","D","E"]})
df2 = pd.DataFrame({'col1':["A","B","D","E"]})

df = pd.concat({'df1':df1, 'df2':df2})
df['f_col1'], uniques = pd.factorize(df['col1'])
print(df)

屈服

      col1  f_col1
df1 0    A       0
    1    B       1
    2    C       2
    3    D       3
    4    E       4
df2 0    A       0
    1    B       1
    2    D       3
    3    E       4

  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

---

要从

df

提取

df1

和

df2

，可以使用

df.loc

：

In [116]: df.loc['df1']
Out[116]: 
  col1  f_col1
0    A       0
1    B       1
2    C       2
3    D       3
4    E       4

In [117]: df.loc['df2']
Out[117]: 
  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

（但请注意，如果可以将向量化操作应用于大数据帧一次而不是多次应用于较小的数据帧，则向量化操作的性能会有所提高，因此最好保持

df

并删除

df1

和

df2

。）

---

或者，如果必须先生成

df1['f_col1']

，然后计算

df2['f_col1']

以后，您可以使用

merge

在

col1

上加入

df1

和

df2

：

import pandas as pd
df1 = pd.DataFrame({'col1':["A","B","C","D","E"]})
df2 = pd.DataFrame({'col1':["A","B","D","E"]})

df1['f_col1'], uniques = pd.factorize(df1['col1'])
df2 = pd.merge(df2, df1, how='left')
print(df2)

屈服

      col1  f_col1
df1 0    A       0
    1    B       1
    2    C       2
    3    D       3
    4    E       4
df2 0    A       0
    1    B       1
    2    D       3
    3    E       4

  col1  f_col1
0    A       0
1    B       1
2    D       3
3    E       4

---

您希望在两组数据之间获得唯一的值。然后创建一个系列或字典。这是可以跨两个数据集使用的因式分解。使用

map

获取所需的输出

u = np.unique(np.append(df1.col1.values, df2.col1.values))
f = pd.Series(range(len(u)), u)  # this is factorization

---

使用

map

df1['f_col1'] = df1.col1.map(f)
df2['f_col1'] = df2.col1.map(f)

---

---

---

您希望在两组数据之间获得唯一的值。然后创建一个系列或字典。这是可以跨两个数据集使用的因式分解。使用

map

获取所需的输出

u = np.unique(np.append(df1.col1.values, df2.col1.values))
f = pd.Series(range(len(u)), u)  # this is factorization

---

使用

map

df1['f_col1'] = df1.col1.map(f)
df2['f_col1'] = df2.col1.map(f)

---

---

---

谢谢这两个数据集并不总是在同一时间可用，因此我无法将它们合并。这些值应该以df1的形式存储，并在df2可用时使用。我添加了一个替代解决方案，允许在

df1['f_col1']

之后计算

df2['f_col1']

。谢谢。这两个数据集并不总是在同一时间可用，因此我无法将它们合并。这些值应该以df1的形式存储，并在df2可用时使用。我添加了一个替代解决方案，允许在

df1['f_col1']

之后计算

df2['f_col1']

。谢谢。我尝试了您的解决方案，但由于数据具有重复的值，因此出现了错误。InvalidIndexError:重新索引仅对唯一值索引对象有效请使用

删除重复项

要删除

df1

中的重复项，请查看更新的部分。谢谢。我尝试了您的解决方案，但由于数据具有重复的值，因此出现了错误。InvalidIndexError:重新索引仅对唯一值索引对象有效请使用

删除重复项

要删除

df1

中的重复项，请检查更新的部分。