Comprendre inplace=True

Question

Dans le pandas Dans la bibliothèque, il existe souvent une option permettant de modifier l'objet sur place, comme dans l'instruction suivante...

df.dropna(axis='index', how='all', inplace=True)

Je suis curieux de savoir ce qui est renvoyé ainsi que la façon dont l'objet est traité lorsque inplace=True est adoptée, alors que lorsque inplace=False .

Toutes les opérations modifient-elles self quand inplace=True ? Et quand inplace=False est un nouvel objet créé immédiatement tel que new_df = self et ensuite new_df est renvoyé ?

Answer 1

Lorsque inplace=True est passée, les données sont renommées sur place (elle ne renvoie rien), donc vous utiliserez :

df.an_operation(inplace=True)

Lorsque inplace=False est passé (c'est la valeur par défaut, donc ce n'est pas nécessaire), effectue l'opération et retourne une copie de l'objet, donc vous utiliserez :

df = df.an_operation(inplace=False)

Answer 2

Dans pandas, est-ce que inplace = True est considéré comme nuisible, ou non ?

TLDR : Oui, oui c'est ça.

• inplace contrairement à ce que son nom indique, elle n'empêche pas la création de copies et n'offre (presque) jamais d'avantages en termes de performances.
• inplace ne fonctionne pas avec le chaînage de méthodes
• inplace peut conduire à SettingWithCopyWarning s'il est utilisé sur une colonne DataFrame, et peut empêcher l'opération de se dérouler, ce qui entraîne des erreurs difficiles à déboguer dans le code.

Les points douloureux ci-dessus sont des pièges courants pour les débutants. La suppression de cette option simplifiera donc l'API.

---

Je ne conseille pas de régler ce paramètre car il ne sert pas à grand-chose. . Voir ce problème GitHub qui propose le inplace soit déprécié dans tout l'api.

On croit souvent à tort que l'utilisation de la inplace=True conduira à un code plus efficace ou optimisé. En réalité, il existe absolument aucun avantage en termes de performance à l'utilisation inplace=True . Les versions in-place et out-of-place créent toutes deux une copie des données. de toute façon La version en place attribue automatiquement la copie en retour.

inplace=True est un piège fréquent pour les débutants. Par exemple, il peut déclencher le SettingWithCopyWarning :

df = pd.DataFrame({'a': [3, 2, 1], 'b': ['x', 'y', 'z']})

df2 = df[df['a'] > 1]
df2['b'].replace({'x': 'abc'}, inplace=True)
# SettingWithCopyWarning: 
# A value is trying to be set on a copy of a slice from a DataFrame

Appeler une fonction sur une colonne de DataFrame avec inplace=True peut ou ne peut pas fonctionner . Cela est particulièrement vrai lorsqu'il s'agit d'indexation en chaîne.

Comme si les problèmes décrits ci-dessus ne suffisaient pas, inplace=True également entrave le chaînage des méthodes . Comparez le fonctionnement de

result = df.some_function1().reset_index().some_function2()

Par opposition à

temp = df.some_function1()
temp.reset_index(inplace=True)
result = temp.some_function2()

Le premier se prête à une meilleure organisation et lisibilité du code.

---

Une autre affirmation à l'appui est que l'API pour set_axis a été récemment modifié de telle sorte que inplace La valeur par défaut est passée de True à False. Voir GH27600 . Excellent travail des développeurs !

Answer 3

La façon dont je l'utilise est

# Have to assign back to dataframe (because it is a new copy)
df = df.some_operation(inplace=False) 

Ou

# No need to assign back to dataframe (because it is on the same copy)
df.some_operation(inplace=True)

CONCLUSION :

 if inplace is False
      Assign to a new variable;
 else
      No need to assign

Answer 4

Le site inplace paramètre :

df.dropna(axis='index', how='all', inplace=True)

sur Pandas et en général signifie :

1. Pandas crée une copie des données originales.

2. ... effectue des calculs

3. ... attribue les résultats aux données d'origine.

4. ... supprime la copie.

Comme vous pouvez le lire dans le reste de mes réponses plus bas, nous avons toujours peut ont une bonne raison d'utiliser ce paramètre, c'est-à-dire la inplace operations mais nous devrions l'éviter si nous le pouvons, car il génère plus de problèmes, comme.. :

1. Votre code sera plus difficile à déboguer (en réalité SettingwithCopyWarning pour vous avertir de ce problème éventuel)

2. Conflit avec le chaînage de méthodes

Donc il y a même des cas où nous devrions déjà l'utiliser ?

Définitivement oui. Si nous utilisons pandas ou n'importe quel outil pour manipuler d'énormes ensembles de données, nous pouvons facilement faire face à la situation où certaines grandes données peuvent consommer toute notre mémoire. Pour éviter cet effet indésirable, nous pouvons utiliser des techniques telles que enchaînement de méthodes :

(
    wine.rename(columns={"color_intensity": "ci"})
    .assign(color_filter=lambda x: np.where((x.hue > 1) & (x.ci > 7), 1, 0))
    .query("alcohol > 14 and color_filter == 1")
    .sort_values("alcohol", ascending=False)
    .reset_index(drop=True)
    .loc[:, ["alcohol", "ci", "hue"]]
)

ce qui rend notre code plus compact (bien que plus difficile à interpréter et à déboguer également) et consomme moins de mémoire car les méthodes enchaînées travaillent avec les valeurs renvoyées par les autres méthodes, ce qui donne lieu à seulement une copie des données d'entrée. Nous pouvons voir clairement, que nous aurons 2 x données originales consommation de mémoire après ces opérations.

Ou nous pouvons utiliser inplace (bien que plus difficile à interpréter et à déboguer également), notre consommation de mémoire sera de 2 x données originales mais notre consommation de mémoire après cette opération reste 1 x données originales Ce qui, si quelqu'un a déjà travaillé avec d'énormes ensembles de données, sait exactement que cela peut être un grand avantage.

Conclusion finale :

Évitez d'utiliser inplace à moins que vous ne travailliez pas avec des données volumineuses et que vous soyez conscient des problèmes possibles en cas d'utilisation de ces données.

Answer 5

Enregistrez-le dans la même variable

data["column01"].where(data["column01"]< 5, inplace=True)

Enregistrez-la dans une variable séparée

data["column02"] = data["column01"].where(data["column1"]< 5)

Mais, vous pouvez toujours écraser la variable

data["column01"] = data["column01"].where(data["column1"]< 5)

FYI : En défaut inplace = False