如何将DataFrame中的列复制N次？

Question

我有一个只有一列的数据框，希望获得一个包含N列、且所有列均与第一列相同的数据框。可以通过简单地复制它来实现：

df[['new column name']] = df[['column name']]

但是我需要创建超过1000个相同的列，所以它无法正常工作。一个重要的事情是列中的数字应该改变，例如如果第一列是0，第n列是n，前一列是n-1。

- Nash Vlasov

---

使用循环... - Tarik

Answer 1

如果是单列数据，您可以使用转置和 pd.concat 来复制它们，然后再将其转置回原始格式，这避免了循环并且应该更快，然后您可以在第二行更改列名称，但不需要处理数据框中的所有数据，这在性能方面是最消耗资源的。

import pandas as pd
df = pd.DataFrame({'Column':[1,2,3,4,5]})

原始数据框：

   Column
0       1
1       2
2       3
3       4
4       5
df = pd.concat([df.T]*1000).T

输出：

   Column  Column  Column  Column  ...  Column  Column  Column  Column
0       1       1       1       1  ...       1       1       1       1
1       2       2       2       2  ...       2       2       2       2
2       3       3       3       3  ...       3       3       3       3
3       4       4       4       4  ...       4       4       4       4
4       5       5       5       5  ...       5       5       5       5

[5 rows x 1000 columns]

df.columns = ['Column'+'_'+str(i) for i in range(1000)]

- Celius Stingher

---

为了使其工作，我改为使用df = pd.concat([df]*1000, axis=1)。我认为这是最易于理解的答案。 - Gramatik

Answer 2

说你有一个df:，其中列名为'company_name'，包含8家公司：

df = {"company_name":{"0":"Telia","1":"Proximus","2":"Tmobile","3":"Orange","4":"Telefonica","5":"Verizon","6":"AT&T","7":"Koninklijke"}}

  company_name
0        Telia
1     Proximus
2      Tmobile
3       Orange
4   Telefonica
5      Verizon
6         AT&T
7  Koninklijke

你可以使用 loop 和 range 来确定要创建多少个相同的列，并执行以下操作：

for i in range(0,1000):
    df['company_name'+str(i)] = df['company_name']

这导致了 df 的 shape:

df.shape
(8, 1001)

即，它复制了相同的列1000次。 duplicated列的名称将与原始列相同，加上一个整数（= +1）：

'company_name', 'company_name0', 'company_name1', 'company_name2','company_name..N'

- sophocles

Answer 3

df

   A  B  C
0  x  x  x
1  y  x  z

使用 df.assign 将“C”列复制 5 次：

n = 5
df2 = df.assign(**{f'C{i}': df['C'] for i in range(1, n+1)})
df2

   A  B  C C1 C2 C3 C4 C5
0  x  x  x  x  x  x  x  x
1  y  x  z  z  z  z  z  z

将n设置为1000可获得所需输出。

---

您也可以直接将结果分配回去：

df[[f'C{i}' for i in range(1, n+1)]] = df[['C']*n].to_numpy()
df
 
   A  B  C C1 C2 C3 C4 C5
0  x  x  x  x  x  x  x  x
1  y  x  z  z  z  z  z  z

- cs95

Answer 4

我认为最有效的方法是使用DataFrame.loc进行索引，而不是使用外部循环。

n = 3
new_df = df.loc[:, ['column_duplicate']*n + 
                   df.columns.difference(['column_duplicate']).tolist()]
print(new_df)

   column_duplicate  column_duplicate  column_duplicate  other
0                 0                 0                 0     10
1                 1                 1                 1     11
2                 2                 2                 2     12
3                 3                 3                 3     13
4                 4                 4                 4     14
5                 5                 5                 5     15
6                 6                 6                 6     16
7                 7                 7                 7     17
8                 8                 8                 8     18
9                 9                 9                 9     19

如果你想添加后缀

suffix_tup = ('a', 'b', 'c')

not_dup_cols = df.columns.difference(['column_duplicate']).tolist()

new_df = (df.loc[:, ['column_duplicate']*len(suffix_tup) + 
                    not_dup_cols]
            .set_axis(list(map(lambda suffix: f'column_duplicate_{suffix}', 
                               suffix_tup)) + 
                      not_dup_cols, axis=1)
         )
print(new_df)


   column_duplicate_a  column_duplicate_b  column_duplicate_c  other
0                   0                   0                   0     10
1                   1                   1                   1     11
2                   2                   2                   2     12
3                   3                   3                   3     13
4                   4                   4                   4     14
5                   5                   5                   5     15
6                   6                   6                   6     16
7                   7                   7                   7     17
8                   8                   8                   8     18

---

或者添加一个索引。

n = 3
not_dup_cols = df.columns.difference(['column_duplicate']).tolist()

new_df = (df.loc[:, ['column_duplicate']*n + 
                    not_dup_cols]
            .set_axis(list(map(lambda x: f'column_duplicate_{x}', range(n))) + 
                      not_dup_cols, axis=1)
         )
print(new_df)

   column_duplicate_0  column_duplicate_1  column_duplicate_2  other
0                   0                   0                   0     10
1                   1                   1                   1     11
2                   2                   2                   2     12
3                   3                   3                   3     13
4                   4                   4                   4     14
5                   5                   5                   5     15
6                   6                   6                   6     16
7                   7                   7                   7     17
8                   8                   8                   8     18
9                   9                   9                   9     19

- ansev