Certaines bibliothèques Python, telles que pandas, NumPy et Pillow (PIL), sont conçues pour que les méthodes puissent être enchaînées et traitées dans l’ordre (= chaînage de méthodes).
Le chaînage de méthodes n’est pas une syntaxe spéciale, car il ne fait que répéter le processus d’appel d’une méthode directement à partir de la valeur de retour.
Le nombre de caractères par ligne a tendance à être long lors de l’utilisation de chaînes de méthodes, mais vous pouvez utiliser des parenthèses pour couper les lignes si nécessaire.
Tout d’abord, cet article décrit les bases suivantes en utilisant les pandas comme exemple.
- Chaînage de méthodes chez les pandas
- Sauts de ligne entre parenthèses
- Utiliser des barres obliques inverses
- Mettre entre parenthèses pour couper les lignes
Ensuite, cet article présente des exemples de NumPy et Pillow (PIL).
- Chaînage de méthodes dans NumPy
- Chaînage de méthodes dans Pillow (PIL)
PEP8, le guide de style Python (conventions de codage), comprend une section sur l’indentation mais ne mentionne pas spécifiquement le chaînage de méthodes.
Il est confirmé que les exemples de codes suivants ne déclenchent aucun avertissement lors de la vérification du codage flake8.
Chaînage de méthodes chez les pandas
De nombreuses méthodes de pandas.DataFrame et pandas.Series renvoient pandas.DataFrame et pandas.Series, et les méthodes peuvent être chaînées.
Si vous n’utilisez pas de chaîne de méthodes, vous pouvez écrire, par exemple, ce qui suit :
Lisez le fichier avec read_csv().
import pandas as pd
df = pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0)
print(df)
# age state point
# name
# Alice 24 NY 64
# Bob 42 CA 92
# Charlie 18 CA 70
# Dave 68 TX 70
# Ellen 24 CA 88
# Frank 30 NY 57
Ajoutez de nouvelles colonnes à ce pandas.DataFrame, supprimez les colonnes inutiles, triez et extrayez uniquement les trois premières lignes.
df = df.assign(point_ratio=df['point'] / 100)
df = df.drop(columns='state')
df = df.sort_values('age')
df = df.head(3)
print(df)
# age point point_ratio
# name
# Charlie 18 70 0.70
# Alice 24 64 0.64
# Ellen 24 88 0.88
Le même processus peut être écrit en connectant les méthodes comme suit.
df_mc = pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0).assign(point_ratio=df['point'] / 100).drop(columns='state').sort_values('age').head(3)
print(df_mc)
# age point point_ratio
# name
# Charlie 18 70 0.70
# Alice 24 64 0.64
# Ellen 24 88 0.88
Bien que le chaînage de méthodes soit pratique et simple à écrire, il peut conduire à des résultats inattendus si vous connectez de nombreuses méthodes que vous ne comprenez pas bien. Si vous ne les connaissez pas, il peut être plus sûr d’appliquer les méthodes une par une et de vérifier les résultats.
Il existe également certains inconvénients, tels que le manque d’achèvement pour la deuxième méthode et les méthodes suivantes dans certains éditeurs.
Sauts de ligne entre parenthèses
En Python, vous pouvez librement couper les lignes entre parenthèses, vous pouvez donc écrire comme suit :
df_mc_break = pd.read_csv(
'data/src/sample_pandas_normal.csv',
index_col=0
).assign(
point_ratio=df['point'] / 100
).drop(
columns='state'
).sort_values(
'age'
).head(
3
)
Notez que même si vous pouvez librement utiliser des sauts de ligne, une erreur est générée si vous sautez une ligne dans un littéral de chaîne.
# df_mc_break = pd.read_csv(
# 'data/src/sample_
# pandas_normal.csv',
# index_col=0
# ).assign(
# point_ratio=df['point'] / 100
# ).drop(
# columns="state"
# ).sort_values(
# 'age'
# ).head(
# 3
# )
# SyntaxError: EOL while scanning string literal
Bien sûr, vous ne pouvez couper les lignes que lorsqu’il y a beaucoup de caractères.
dfdf_mc_break_mc = pd.read_csv(
'data/src/sample_pandas_normal.csv', index_col=0
).assign(
point_ratio=df['point'] / 100
).drop(columns='state').sort_values('age').head(3)
Utiliser des barres obliques inverses
En Python, la barre oblique inverse () est un caractère de continuation et, lorsqu’elle est placée à la fin d’une ligne, elle ignore les sauts de ligne suivants et considère la ligne comme continue.
En utilisant ceci, vous pouvez écrire ce qui suit.
df_mc_break_backslash = pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0)
.assign(point_ratio=df['point'] / 100)
.drop(columns='state')
.sort_values('age')
.head(3)
Mettre entre parenthèses pour couper les lignes
Vous pouvez également utiliser la règle selon laquelle vous pouvez librement couper les lignes entre parenthèses et mettre tout le code entre parenthèses ().
df_mc_break_parens = (
pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0)
.assign(point_ratio=df['point'] / 100)
.drop(columns='state')
.sort_values('age')
.head(3)
)
Dans ce cas également, vous êtes libre d’utiliser ou non des sauts de ligne, vous pouvez donc écrire ce qui suit.
df_mc_break_parens = (pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0)
.assign(point_ratio=df['point'] / 100)
.drop(columns='state')
.sort_values('age')
.head(3))
Mettre un point (. ) à la fin d’une ligne ne provoque pas d’erreur. Cependant, dans ce cas, il peut être difficile de voir qu’il s’agit d’une chaîne de méthodes, vous devez donc l’éviter.
df_mc_break_parens = (
pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0).
assign(point_ratio=df['point'] / 100).
drop(columns='state').
sort_values('age').
head(3)
)
De même, vous pouvez écrire une longue chaîne en utilisant des parenthèses pour couper les lignes dans le code. Voir l’article suivant.
Chaînage de méthodes dans NumPy
Il existe plusieurs méthodes de tableau NumPy ndarray qui renvoient ndarray.
Exemple sans chaînage de méthodes :
import numpy as np
a = np.arange(12)
a = a.reshape(3, 4)
a = a.clip(2, 9)
print(a)
# [[2 2 2 3]
# [4 5 6 7]
# [8 9 9 9]]
Exemple avec chaînage de méthodes :
a_mc = np.arange(12).reshape(3, 4).clip(2, 9)
print(a_mc)
# [[2 2 2 3]
# [4 5 6 7]
# [8 9 9 9]]
Couper une ligne en la mettant entre parenthèses.
a_mc_break_parens = (
np.arange(12)
.reshape(3, 4)
.clip(2, 9)
)
print(a_mc_break_parens)
# [[2 2 2 3]
# [4 5 6 7]
# [8 9 9 9]]
Notez que dans NumPy, de nombreuses opérations sont définies comme des fonctions avec ndarray comme argument, plutôt que comme des méthodes de ndarray, vous ne pouvez donc pas tout faire avec une chaîne de méthodes comme vous le pouvez avec pandas.
Chaînage de méthodes dans Pillow (PIL)
Dans la bibliothèque de traitement d’images Pillow(PIL), les images sont représentées par le type Image. Certaines méthodes de Image renvoient également l’image traitée.
Exemple sans chaînage de méthodes :
Un fichier image est chargé, divers processus sont exécutés et enfin, il est enregistré sous un autre fichier.
from PIL import Image, ImageFilter
im = Image.open('data/src/lena_square.png')
im = im.convert('L')
im = im.rotate(90)
im = im.filter(ImageFilter.GaussianBlur())
im.save('data/temp/lena_square_pillow.jpg', quality=95)
Exemple avec chaînage de méthodes :
Image.open('data/src/lena_square.png').convert('L').rotate(90).filter(ImageFilter.GaussianBlur()).save('data/temp/lena_square_pillow.jpg', quality=95)
Couper une ligne en la mettant entre parenthèses.
Cet exemple peut sembler un peu étrange car si vous faites tout du chargement à l’enregistrement en même temps, vous pouvez terminer le processus sans affecter la valeur de retour à une variable.
(
Image.open('data/src/lena_square.png')
.convert('L')
.rotate(90)
.filter(ImageFilter.GaussianBlur())
.save('data/temp/lena_square_pillow.jpg', quality=95)
)