[Python] Comment ajouter des lignes et des colonnes à une table (pandas DataFrame)

Quelques façons d'ajouter de nouvelles colonnes et lignes à une table créée.

Il existe d'autres fonctions et méthodes qui peuvent être utilisées, mais pour le moment, seules les bases.

**table des matières**

[Table d'origine](# 1 table d'origine)
[Ajouter une colonne](# 2 Ajouter une colonne)
1. df['A']
Ajouter une colonne (liste) (liste #Ajouter une colonne)
[Ajouter une colonne (numéro)](#Ajouter une colonne)
[Ajouter une colonne (table)](#Ajouter une table de colonnes)
[Ajouter une colonne (formule)](#Ajouter une formule de colonne)
[méthode assign](méthode #assign)
[méthode join](méthode #join)
[Ajouter une table avec tous les mêmes noms de ligne](# Ajouter une table avec tous les mêmes noms de ligne Pas de noms de colonne en double)
[Ajouter une table avec des noms de lignes inexistants](#Add table avec des noms de lignes inexistants)
[Lorsque les noms de colonnes sont dupliqués](# Lorsque les noms de colonnes sont dupliqués)
[Lorsque certains noms de colonnes sont dupliqués](#Lorsque certains noms de colonnes sont dupliqués)
[fonction concat](colonne de fonction #concat)
[Table jointe](# Colonne de table jointe)
[Présence / absence d'axe = 1](colonne présence / absence de # axis1)
[option de tri](colonne #sort option)
[option de jointure](colonne d'options #join)
[Ajouter une ligne](ligne n ° 3 ajoutée)
[méthode loc](méthode #loc)
[Ajouter une ligne (liste)](# Ajouter une liste de lignes)
[Ajouter une ligne (valeur numérique)](#Nombre supplémentaire de ligne)
[Ajouter une ligne (table)](#Add Row Table)
[Add Row (Formula)](#Add Row Formula)
[fonction concat](ligne de fonction #concat)
[Join table](# join table row)
Par défaut (#default)
[option de tri](#sort option ligne)
[option de jointure](ligne d'option #join)

## 1. 1. Table originale Ajouter des lignes et des colonnes basées sur un tableau 3 par 3 .. Stocké dans la variable df.

`Création de table de base`


row0 = [1, 2, 3]
row1 = [10, 20, 30]
row2 = [100, 200, 300]

df = pd.DataFrame([row0,row1,row2], columns=['col0','col1','col2'])
df.index = ['row0', 'row1', 'row2']

df

## 2. Ajouter une colonne Intuitivement faciles à utiliser sont `df ['A']` et ʻassign`.

・ Df ['A'] ・ Attribuer une méthode ・ Méthode de jointure ・ Fonction Concat

■df['A'] df['A'] = B └ "df": table d'origine └ "A": nom de la colonne à ajouter └ "B": ce qu'il faut ajouter

Si vous spécifiez un nom de ligne existant, il sera écrasé.

Vous pouvez spécifier ce que vous souhaitez ajouter relativement librement. Des valeurs numériques, des valeurs, des données de table, des formules, des listes, etc. peuvent être utilisées.

** ▼ Étude de cas ** ① Ajouter une colonne (liste) ② Ajout de colonnes (valeur numérique) ③ Ajouter une colonne (table) ④ Ajouter une colonne (formule)

#### ① Ajouter une colonne (liste)

`Ajouter une colonne (liste)`


df['col3'] = [4, 40, 400]
df

#### ② Ajout de colonnes (valeur numérique)

`Ajouter une colonne (nombre)`


df['col3'] = 4
df

#### ③ Ajouter une colonne (table)

`Ajouter une colonne (table)`


df['col3'] = df['col2']
df

#### ④ Ajouter une colonne (formule)

`Ajouter une colonne (formule)`


df['col3'] = df['col2'] * 100
df

## ■ méthode d'affectation Vous pouvez également ajouter en spécifiant le nom de la colonne avec la méthode assign. `df.assign(A=[a,b,,], B=[c,d,,],,)` └ "A" "B": nom de colonne à ajouter └ "a, b ,," "c, d ,,": Contenu de chaque colonne

・ Non écrasé ・ Aucun quota requis pour les noms de colonnes -Si l'élément est spécifié par liste, il doit correspondre au nombre de lignes de la table de base.

> Exemple d'erreur ・ Il y a un quota dans le nom de la colonne SyntaxError: expression cannot contain assignment, perhaps you meant "=="?

・ Aucun nom de colonne TypeError: assign() takes 1 positional argument but 2 were given

・ Le nombre d'éléments dans la liste ne correspond pas ValueError: Length of values does not match length of index

** ▼ 1 ligne ajoutée **

`1 ligne ajoutée`


df.assign(A=[1,2,3])

** ▼ 1 colonne ajoutée (données du tableau / formule) **

`1 colonne ajoutée (données de table / formule)`


df.assign(A=df['col0']*100)

** ▼ 2 colonnes ajoutées **

`2 colonnes ajoutées`


df.assign(A=[1,2,3], B=100)

Si vous ajoutez "nom de colonne = contenu", le nombre de colonnes augmentera.

## ■ méthode de jointure La méthode de jointure peut être utilisée pour joindre des tables. Il ne peut pas être utilisé pour des choses qui n'ont pas de numéro de ligne (index) comme une liste et des nombres.

join(dfA, rsuffix='_a') └ "dfA": Table à joindre └ "rsuffix = '_ a'": Si les noms de colonnes sont dupliqués, ajoutez "_a" (facultatif) aux noms de colonnes ajoutés.

Si "lsuffix = '_ a'", changez le nom de la colonne existante.

** ▼ Étude de cas ** Vérifiez le traitement de chaque motif de la table à ajouter.

(1) Ajouter une table avec les mêmes noms de ligne (pas de noms de colonne en double) (2) Ajouter une table avec des noms de lignes qui n'existent pas ③ Lorsque le nom de la colonne est dupliqué ④ Lorsque certains noms de colonnes sont dupliqués

#### (1) Ajouter une table avec le même nom de ligne (pas de noms de colonne en double)

Lorsque le nom de ligne correspond au nom de ligne de la table de base et que le nom de colonne ne chevauche pas celui existant.

`Table avec le même nom de ligne`


dfA = pd.DataFrame([100,200,300])
dfA.index = ['row0', 'row1', 'row2']
dfA

** ▼ Ajouter **

`ajouter à`


df.join(dfA)

Une nouvelle colonne a été ajoutée.

#### (2) Ajouter une table avec des noms de lignes qui n'existent pas

S'il existe un nom de ligne qui n'existe pas dans la table de base └ ** Aucune nouvelle ligne n'est ajoutée à la table de base **. └ ** Les données dont les noms de ligne ne correspondent pas seront NaN ** (valeur manquante).

** ▼ Tableau à ajouter ** Seule la ligne 0 existe. XXX et YYY ne figurent pas dans la table de base.

`Table avec des noms de ligne inexistants`


dfB = pd.DataFrame([100,200,300])
dfB.index = ['row0', 'XXX', 'YYY']
dfB

** ▼ Ajouter **

`ajouter à`


df.join(dfB)

#### ③ Lorsque le nom de la colonne est dupliqué `join(dfA, rsuffix='_a')`

Si le nom de colonne est dupliqué, spécifiez le dernier caractère à ajouter au nom de colonne dupliqué avec "rsuffix = '_ a'".

** ▼ Options **

"Rsuffix = '_ a'": ** Ajouter le caractère spécifié au nom de colonne en double ** à ajouter (abréviation du suffixe de droite)
"Lsuffix = '_ a'": ** Ajouter le caractère spécifié au nom de colonne en double existant ** (abréviation du suffixe gauche)

** Si non spécifié, une erreur ** se produira.
** ▼ Tableau à ajouter ** Une table qui contient le même nom de colonne (col0) qu'une table existante.

`Nom de colonne en double`


dfC = pd.DataFrame([100,200,300], columns=['col0'])
dfC.index = ['row0', 'row1', 'XXX']
dfC

** ▼ Ajouter (pour rsuffix) **

`rsuffix`


df.join(dfC, rsuffix='_@')

** ▼ Ajouter (pour lsuffix) **

`rsuffix`


df.join(dfC, lsuffix='_@')

#### ④ Lorsque certains noms de colonnes sont dupliqués Le processus est le même que lorsque le nom de la colonne dans ③ est dupliqué.

-Les colonnes en double ont le suffixe spécifié dans le nom de la colonne. -Les noms de colonnes qui ne se chevauchent pas sont ajoutés tels quels.

** ▼ Tableau à ajouter ** Une table qui contient les mêmes noms de colonne (col0, col1) qu'une table existante.

`Noms de colonnes partiellement dupliqués`


list1 = [100,200,300]
list2 = ['A','B','C']
list3 = ['AAA','BBB','CCC']
list4 = ['10A','20B','30C']

dfD = pd.DataFrame([list1,list2, list3, list4], columns=['col0', 111,'col1'])
dfD.index = ['row0', 'row1', 'XXX', 'YYY']
dfD

** ▼ Ajouter **

`rsuffix`


df.join(dfD, rsuffix='_@')

La chaîne de caractères spécifiée est ajoutée au nom de colonne en double
Les lignes qui n'existent pas dans la table de base ne sont pas ajoutées --NaN est entré dans la ligne qui n'existe pas dans la colonne à ajouter.

## ■ fonction concat (colonne) Joindre des tables à l'aide de la fonction concat.

pd.concat([df, dfA], axis=1) └ "df": table de base └ "dfA": Table à ajouter └ "axis = 1": Instruction pour ajouter une colonne

-Ajouter tel quel même si le nom de la colonne est dupliqué -Ajouter une nouvelle ligne si le nom de la ligne est différent (par défaut: join = 'outside') -Avec l'option join = 'inner', ne laissez que ceux avec des noms de ligne correspondants

① Table à rejoindre ② Présence ou absence d'axe = 1 ③ option de tri ④ option de jointure
> ・ La liste et les valeurs numériques ne peuvent pas être combinées -TypeError: cannot concatenate object of type ''; only Series and DataFrame objs are valid

・ Signification de "concat" concaténer: concaténer. relier.

### ① Table à joindre (colonne) Utilisez le tableau "dfA" en 3 lignes et 3 colonnes ci-dessous.

-Les colonnes "col0" et "col1" se chevauchent avec la table de base. -La ligne "xxx" n'est pas dans la table de base

`Table à rejoindre`


list1 = [1,100,'AAA']
list2 = [2,200,'BBB']
list3 = [3,300,'CCC']

dfE = pd.DataFrame([list1,list2, list3], columns=['col0', 'col1', 'aaa'])
dfE.index = ['row0', 'row1', 'XXX']
dfE

### ② Présence / absence d'axe = 1 (colonne) `pd.concat([df, dfA], axis=1)`

** "axis = 1" est requis lors de l'ajout de colonnes **. S'il n'est pas attaché, il sera ajouté dans le sens des lignes et le résultat sera significativement différent.

** ▼ Il y a "axis = 1" **

`「axis=1 "Oui`


pd.concat([df, dfA], axis=1)

・ Ajouter une colonne -Ajouter tel quel même si le nom de la colonne est dupliqué (différent de la méthode de jointure) -La valeur de la ligne ne figurant pas dans la table à ajouter est NaN. -Ajout de nouvelles lignes qui ne sont pas dans la table de base.

** ▼ "axis = 1" Aucun ** La forme dans laquelle "axis = 0" est omis. Il sera combiné dans le sens des lignes.

`「axis=1 "aucun`


pd.concat([df, dfA])

-Si les noms de colonne ne correspondent pas, une nouvelle colonne est ajoutée. -Même si le nom de la ligne est dupliqué, tous sont nouvellement ajoutés.

** * Les colonnes sont ajoutées, mais les lignes ne sont pas intégrées, donc c'est différent de ce que vous voulez exécuter. ** **

### ③ option de tri (colonne) Si vous joignez les tables sans l'option de tri, elles seront automatiquement triées par nom de ligne. └ Par défaut: `sort = True`
** ▼ sort = True (par défaut) **

`sort=True`


pd.concat([df, dfA], axis=1)

La ligne "XXX" propose un tri automatique.

**▼sort=False**

`sort=False`


pd.concat([df, dfA], axis=1, sort=False)

Si vous écrivez "sort = False", la ligne ajoutée sera ajoutée à la fin.

** ▼ Lorsque la table de base est remplacée **

`sort=False`


pd.concat([dfA, df], axis=1, sort=False)

Une ligne qui n'existe pas dans la base "dfA" est ajoutée à la fin.

### ④ option de jointure (colonne) Déterminer le traitement de ligne (lorsque l'axe = 1)

join='outer' └ Réglage par défaut. └ Laissez une ligne qui n'existe pas.

join='inner' └ Ne laissez que les lignes en double.

**▼join='outer'**

`join='outer'`


pd.concat([dfA, df], axis=1)

Une ligne "XXX" qui n'existe pas avant et après la fusion est ajoutée.

**▼join='inner'**

`join='outer'`


pd.concat([dfA, df], axis=1, join='inner')

Suppression des lignes "row2" et "XXX" qui n'existent que dans l'un ou l'autre.

## 3. 3. Ajouter une ligne La méthode loc est intuitivement facile à utiliser.

・ Méthode Loc ・ Fonction Concat

■ méthode loc

df.loc['A']=B └ "df": table d'origine └ "A": Nom de la ligne à ajouter └ "B": ce qu'il faut ajouter

Si vous spécifiez un nom de ligne existant, il sera écrasé.

Vous pouvez spécifier ce que vous souhaitez ajouter relativement librement. Des valeurs numériques, des valeurs, des données de table, des formules, des listes, etc. peuvent être utilisées.

① Ajouter une ligne (liste) ② Ajouter une ligne (valeur numérique) ③ Ajouter une ligne (tableau) ④ Ajouter une ligne (formule)

#### ① Ajouter une ligne (liste)

`Ajouter une ligne (liste)`


df.loc['AAA'] = [4, 40, 400]
df

#### ② Ajouter une ligne (valeur numérique)

`Ajouter une ligne (numéro)`


df.loc['AAA'] = 4
df

#### ③ Ajouter une ligne (tableau)

`Ajouter une ligne (table)`


df.loc['AAA'] = df.loc['row2']
df

#### ④ Ajouter une ligne (formule)

`Ajouter une ligne (formule)`


df.loc['AAA'] = df.loc['row2'] * 100
df

## ■ fonction concat (ligne) Joindre des tables à l'aide de la fonction concat.

pd.concat([df, dfA]) └ "df": table de base └ "dfA": Table à ajouter

-Ajouter tel quel même si le nom de la ligne est dupliqué -Ajouter une nouvelle colonne si le nom de la colonne est différent (par défaut: join = 'outside') -Avec l'option join = 'inner', ne laissez que ceux avec des noms de colonne correspondants

① Table à rejoindre ② Par défaut ③ option de tri ④ option de jointure
> ・ La liste et les valeurs numériques ne peuvent pas être combinées -TypeError: cannot concatenate object of type ''; only Series and DataFrame objs are valid

・ Signification de "concat" concaténer: concaténer. relier.

### ① Table à joindre (ligne) Utilisez le tableau «dfA» en 2 lignes et 3 colonnes ci-dessous.

`Table à rejoindre`


list1 = [1,100,'AAA']
list2 = [2,200,'BBB']

dfA = pd.DataFrame([list1,list2], columns=['col0', 'col1', 'aaa'])
dfA.index = ['row0', 'XXX']
dfA

#### ② Par défaut `pd.concat([df, dfA])`

`Défaut`


pd.concat([df, dfA])

-Même si le nom de la ligne est dupliqué, tous sont nouvellement ajoutés. -Ajouter une nouvelle colonne pour les noms de colonnes incompatibles. ・ Les cellules non applicables sont remplies de NaN (valeur manquante)

### ③ option de tri (ligne) Si vous rejoignez une table sans spécifier l'option de tri, elle sera automatiquement triée par nom de colonne. └ Par défaut: `sort = True`
** ▼ sort = True (par défaut) **

`sort=True`


pd.concat([df, dfA])

La colonne "aaa" ajoutée plus tard arrive en tête par tri automatique.

**▼sort=False**

`sort=False`


pd.concat([df, dfA], sort=False)

La colonne "aaa" ajoutée ultérieurement est jointe à la fin.

### ④ option de jointure (ligne) Décidez comment gérer la colonne.

join='outer' └ Réglage par défaut. └ Laissez une colonne qui n'existe pas.

join='inner' └ Ne laissez que les colonnes en double.

**▼join='outer'**

`join='outer'(Défaut)`


pd.concat([df, dfA])

La colonne "aaa" qui n'existe pas dans la table avant et après la jointure reste.

**▼join='inner'**

`join='inner'`


pd.concat([df, dfA], join='inner')

Seules les colonnes qui existent dans les deux tables avant et après la jointure restent.

Retour en haut (#python comment ajouter des lignes et des colonnes à une table pandas dataframe)