Gestionnaire d’interpolation de chaînes de caractères (C# 10)

Cet article fait partie d’une série d’articles sur les apports fonctionnels de C# 10.0.

Sommaire

Interpolation de chaîne de caractères
Options d’alignement et de formatage
Echappement des caractères spéciaux
Verbatim string

Interpolation de chaînes constantes

Gestionnaire d’interpolation de chaînes de caractères
Attribut InterpolatedStringHandler
Attribut InterpolatedStringHandlerArgument

Cette fonctionnalité permet d’apporter une solution pour faciliter et personnaliser l’interpolation de chaînes de caractères.

Avant C# 10.0, le traitement appliqué lors de l’interpolation de chaînes de caractères ne pouvait pas être modifié ni personnalisé. C# 10.0 introduit l’attribut InterpolatedStringHandler dans le but d’implémenter un traitement personnalisé lorsqu’une interpolation de chaînes de caractères est effectuée.

Interpolation de chaîne de caractères

Pour rappel l’interpolation de chaîne de caractères consiste à faciliter la construction d’une chaîne de caractères en permettant d’interpoler des expressions qui seront évaluées au moment de la construction de la chaîne.

Par exemple:

int wordCount = 5;
string interpolationExample = $"Ceci est un exemple contenant {2 * wordCount} mots provenant de la variable '{nameof(wordCount)}'";

interpolationExample contient la chaîne "Ceci est un exemple contenant 10 mots provenant de la variable 'wordCount'" qui provient de l’interpolation de 2 expressions:

  • 2 * wordCount renvoyant 10 et
  • nameof(wordCount) renvoyant "wordCount".

Options d’alignement et de formatage

L’interpolation peut être affinée en utilisant d’autres options de construction des expressions interpolées. La forme générale des expressions est:

{<expression interpolée>[,<option d'alignement>][:<option de formatage>]}

Ainsi:

  • L’option d’alignement permet d’indiquer une constante correspondant au nombre minimum de caractères de l’expression.
  • Si la chaîne est trop courte et que la constante est positive: la chaîne sera alignée à droite et la longueur sera complétée par des espaces.
  • Si la chaîne est trop courte et que la constante est négative: la chaîne sera alignée à gauche et la longueur sera complétée par des espaces.

L’option de formatage suivant le type du résultat de l’expression permet d’apporter une indication sur le formatage à appliquer (voir Format string component pour des exemples d’options de formatage).

Par exemple, si on exécute:

string example1 = $"'{1,6}'";    // chaine de caractères trop courte, alignement à droite
Console.WriteLine(example1);

On obtient:

'     1'

Avec:

string example2 = $"'{1,-6}'";   // chaine de caractères trop courte, alignement à gauche
Console.WriteLine(example2);

On obtient:

'1     '

Avec:

string example3 = $"'{1234567,6}'"; // Chaîne assez longue, pas d'ajout de caractères
Console.WriteLine(example3);

Le résultat es:

'1234567'

Concernant l’option de formatage, l’option dépend du type de la valeur résultant de l’évaluation de l’expression. Si on considère un nombre décimal pour lequel on ne garde que 3 chiffres significatifs, on appliquera l’option de formatage '0.000' (voir les options de formatage des nombres):

string example4 = $"{45235.776522:0.000}";
Console.WriteLine(example4);

45235.776

Echappement des caractères spéciaux

Pour échapper les caractères { et }, il faut utiliser respectivement {{ et }}, par exemple:

int number = 5742;
string example5 = $"Le nombre {number} est affiché avec {{number}}.";
Console.WriteLine(example5);

Le nombre 5742 est affiché avec {number}.

Pour éviter que le caractère : ne soit évalué dans une expression comme une option de formatage, il faut entourer l’expression ternaire utilisant : avec ( et ). Par exemple:

int limit = 7;
string exemple6 = $"La limite est: {limit > 5 ? "haute" : "basse"}";  // ERREUR
string exemple6 = $"La limite est: {(limit > 5 ? "haute" : "basse")}";  // OK

Verbatim string

Dans une chaîne de caractères simple, on peut échapper les caractères spéciaux en utilisant @, par exemple pour le chemin d’un fichier:

string exemple7 = @"C:\MyFolder\InnerFolder\File.txt";

Il est possible d’associer une verbatim string avec des interpolations en utilisant @$ ou $@, par exemple:

string innerFolderName = "TheInnerFolder";
string exemple8 = $@"C:\MyFolder\{innerFolderName}\File.txt";
string exemple9 = @$"C:\MyFolder\{innerFolderName}\File.txt";

Interpolation de chaînes constantes

C# 10.0

Antérieurement à C# 10, l’interpolation de chaînes de caractères n’était pas possible pour les chaînes constantes toutefois il était possible d’effectuer des concaténations de chaînes constantes:

public const string constIntegerAsString = "5";
public const string stringInterpolationExample = $"Number {constIntegerAsString} is five !!";  // ERREUR avant C# 10 
public const string constantStringExample = "Number " + constIntegerAsString + " is five !!";  // OK

La concaténation est possible car le compilateur construit une chaine de caractères unique à la compilation ce que n’était pas le cas de l’interpolation avant C# 10. Si on regarde le code MSIL correspondant à cette méthode:

public void ExecuteMe()
{
    Console.WriteLine(constantStringExample);
}

On peut voir que la concaténation correspond à une chaîne constante:

.method public hidebysig instance void  ExecuteMe() cil managed
{
  // Code size       11 (0xb)
  .maxstack  8
  IL_0000:  ldstr      "Number 5 is five !!"
  IL_0005:  call       void [System.Console]System.Console::WriteLine(string)
  IL_000a:  ret
}

Avec C# 10, le compilateur a été amélioré pour permettre les interpolations de chaînes constantes:

public const string constIntegerAsString = "5";
public const string stringInterpolationExample = $"Number {constIntegerAsString} is five !!";    // OK à partir de C# 10

Si on regarde le code MSIL de la méthode suivante, on peut se rendre compte que le code est identique à celui plus haut: 

public void ExecuteMe()
{
    Console.WriteLine(stringInterpolationExample);
}

De même que pour la concaténation, dans le cas de l’interpolation, le compilateur effectue la construction de la chaîne directement lors de la compilation.

L’interpolation pour une chaîne de caractères constante n’est possible que si l’interpolation est effectuée avec d’autres chaînes constantes. Il n’est pas possible d’effectuer une interpolation avec des variables dont le type nécessite une conversion.

Les exemples suivants génèrent une erreur de compilation:

public const int constInteger = 5;
public const string stringInterpolationExample = $"Number {constInteger} is five !!";   // ERREUR

L’interpolation "{constInteger}" nécessite une conversion d’un entier vers une chaîne de caractères qui doit être effectuée à l’exécution en prenant en compte les paramètres régionaux. Cette conversion ne peut être effectuée à la compilation.

Gestionnaire d’interpolation de chaînes de caractères

C# 10.0

C# 10.0 permet d’implémenter des classes qui peuvent effectuer des traitements personnalisés à la suite d’interpolation de chaînes de caractères. L’intérêt est d’être flexible sur le traitement effectué en utilisant les avantages de la syntaxe de l’interpolation de chaînes. Le traitement peut consister à construire une chaîne de caractères en utilisant les expressions à évaluer comme c’est le cas pour une interpolation de chaîne normale mais il n’est pas obligatoire de construire une chaîne de caractères.

L’implémentation de la classe correspondant à un gestionnaire de chaînes de caractères doit répondre à certaines conditions:

  • Il faut utiliser l’attribut InterpolatedStringHandlerAttribute
  • Le constructeur doit accepter au moins 2 arguments entier:
    • literalLength permettant d’indiquer la longueur de la chaine de caractères.
    • formattedCount indiquant le nombre d’éléments pour lesquels il faudra effectuer un traitement de formatage.
  • Une méthode publique void AppendLiteral(string s) pour ajouter une chaîne où aucun traitement n’est nécessaire.
  • Une méthode publique void AppendFormatted<T>(T t) acceptant un objet pour lequel un formatage est nécessaire.

Attribut InterpolatedStringHandler

A titre d’exemple, on considère les 2 objets suivants:

public class TwoDimensionPoint
{
    public TwoDimensionPoint(int x, int y)
    {
        X = x;
        Y = y;
    }

    public int X { get; set; }
    public int Y { get; set; }
}

public class ThreeDimensionPoint
{
    public ThreeDimensionPoint(int x, int y, int z)
    {
        X = x;
        Y = y;
        Z = z;
    }

    public int X { get; set; }
    public int Y { get; set; }
    public int Z { get; set; }
}

Si on souhaite générer une chaîne de caractères contenant les valeurs des membres de ces 2 classes, une première approche est de surcharger les fonctions ToString():

public class TwoDimensionPoint
{
    // ...
    public override string ToString()
    {
        return $"{X}; {Y}";
    }
}

public class ThreeDimensionPoint
{
    // ...

    public override string ToString()
    {
        return $"{X}; {Y}; {Z}";
    }
}

Avec cette implémentation, on doit surcharger ToString() pour les 2 objets. Si on a de nombreux objets pour lesquels on doit surcharger ToString(), cela peut rendre l’implémentation assez fastidieuse. Une autre approche pourrait être de rassembler le traitement de conversion en chaîne de caractères dans un seul objet.

Avec C# 10, avec un gestionnaire de chaînes de caractères il est possible d’implémenter une classe qui va gérer les interpolations de chaînes de caractères pour des types particuliers et ainsi permettre de rassembler les conversions en chaînes de caractères dans une seule classe. Ainsi si on considère la classe suivante dont les caractéristiques correspondantes aux conditions indiquées précédemment:

[InterpolatedStringHandler]
public class PointStringFormatter
{
    StringBuilder builder;

    public PointStringFormatter(int literalLength, int formattedCount)
    {
        builder = new StringBuilder(literalLength);
        Console.WriteLine($"\tliteral length: {literalLength}, formattedCount: {formattedCount}");
    }

    public void AppendLiteral(string s)
    {
        builder.Append(s);
    }

    public void AppendFormatted<T>(T t)
        where T: class 
    {
        if (t is null)
            AppendLiteral("null");
        if (t is ThreeDimensionPoint threeDimensionPoint)
            AppendLiteral($"{threeDimensionPoint.X}; {threeDimensionPoint.Y}; {threeDimensionPoint.Z}");
        else if (t is TwoDimensionPoint twoDimensionPoint)
            AppendLiteral($"{twoDimensionPoint.X}; {twoDimensionPoint.Y}");
        else if (t is string)
            AppendLiteral(t as string);
        else
            throw new InvalidOperationException($"{nameof(T)} is unknown");
    }

    public override string ToString()
    {
        return this.GetFormattedText();
    }

    internal string GetFormattedText() => builder.ToString();
}

Dans la méthode AppendFormatted(), on peut voir que la conversion des 2 types ThreeDimensionPoint et TwoDimensionPoint est gérée. Ainsi, dans le cas où il est nécessaire d’avoir une implémentation particulière pour un grand nombre de classes, il peut être plus aisé de rassembler les logiques de conversion dans une même méthode.

On peut améliorer l’implémentation de la méthode AppendFormatted() en utilisant le pattern matching plutôt que des if...then...else:

public void AppendFormatted<T>(T t)
    where T: class 
{
    string pointAsString = t switch
    {
        ThreeDimensionPoint threeDimensionPoint => $"{threeDimensionPoint.X}; {threeDimensionPoint.Y}; {threeDimensionPoint.Z}",
        TwoDimensionPoint twoDimensionPoint => $"{twoDimensionPoint.X}; {twoDimensionPoint.Y}",
        null => "null",
        string formattedString => formattedString,
        _ => throw new InvalidOperationException($"{nameof(T)} is unknown")
    };

    AppendLiteral(pointAsString);
}

Si on définit la méthode suivante:

public void ShowPoint(PointStringFormatter point)
{
    Console.WriteLine(point.GetFormattedText());
}

On peut utiliser directement la classe PointStringFormatter en exécutant:

var point1 = new ThreeDimensionPoint(4, 7, 9);
var point2 = new TwoDimensionPoint(4, 7);

ShowPoint($"{nameof(point1)}: {point1}");
ShowPoint($"{nameof(point2)}: {point2}");

Le résultat est:

literal length: 2, formattedCount: 2
point1: 4; 7; 9
literal length: 2, formattedCount: 2
point2: 4; 7

Ainsi comme on peut le constater, l’instanciation de l’objet PointStringFormatter est effectuée à partir d’une chaîne de caractères à interpoler. De façon plus explicite, on pourrait écrire:

var point1 = new ThreeDimensionPoint(4, 7, 9);
PointStringFormatter pointFormatter = $"{nameof(point1)}: {point1}";
Console.WriteLine(pointFormatter);  // Execution de PointStringFormatter.ToString()

Le résultat est le même que précédemment.

La même instance de PointStringFormatter peut servir pour les 2 types d’objets:

var point1 = new ThreeDimensionPoint(4, 7, 9);
var point2 = new TwoDimensionPoint(4, 7);

PointStringFormatter pointFormatter = $"{nameof(point1)}: {point1} / {nameof(point2)}: {point2}";
Console.WriteLine(pointFormatter);

Le résultat est similaire à l’exemple précédent:

literal length: 7, formattedCount: 4
point1: 4; 7; 9 / point2: 4; 7

On peut observer que l’instanciation d’un gestionnaire d’interpolation de chaînes de caractères peut se faire implicitement à partir d’une chaîne de caractères à interpoler. Ainsi, on peut facilement implémenter des comportements spécifiques pour:

  • Effectuer des conversions de classes en chaînes de caractères,
  • Faciliter des logs particuliers suivant des types d’objets,
  • Centraliser dans une même classe les conversions en chaînes de types d’objets différents.
Gestionnaire par défaut: DefaultInterpolatedStringHandler

Si on regarde le code MSIL correspondant au code suivant:

int number = 5742;
string example5 = $"Le nombre {number} est affiché avec {{number}}.";
Console.WriteLine(example5);

On peut voir:

// Code size       61 (0x3d)
.maxstack  3
.locals init (int32 V_0,
         valuetype [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler V_1)
IL_0000:  ldc.i4     0x166e
IL_0005:  stloc.0
IL_0006:  ldloca.s   V_1
IL_0008:  ldc.i4.s   37
IL_000a:  ldc.i4.1
IL_000b:  call       instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::.ctor(int32,
                                                                                                                           int32)
IL_0010:  ldloca.s   V_1
IL_0012:  ldstr      "Le nombre "
IL_0017:  call       instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::AppendLiteral(string)
IL_001c:  ldloca.s   V_1
IL_001e:  ldloc.0
IL_001f:  call       instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::AppendFormatted<int32>(!!0)
IL_0024:  ldloca.s   V_1
IL_0026:  ldstr      bytearray (20 00 65 00 73 00 74 00 20 00 61 00 66 00 66 00   //  .e.s.t. .a.f.f.
                                69 00 63 00 68 00 E9 00 20 00 61 00 76 00 65 00   // i.c.h... .a.v.e.
                                63 00 20 00 7B 00 6E 00 75 00 6D 00 62 00 65 00   // c. .{.n.u.m.b.e.
                                72 00 7D 00 2E 00 )                               // r.}...
IL_002b:  call       instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::AppendLiteral(string)
IL_0030:  ldloca.s   V_1
IL_0032:  call       instance string [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::ToStringAndClear()
IL_0037:  call       void [System.Console]System.Console::WriteLine(string)
IL_003c:  ret

On peut y voir que le gestionnaire DefaultInterpolatedStringHandler est utilisé pour l’interpolation des chaînes de caractères. C’est le gestionnaire par défaut pour traiter les chaînes de caractères interpolées.

ref struct
Un intérêt d’utiliser un gestionnaire de chaînes de caractères interpolées est de prévoir une implémentation optimisée pour minimiser l’utilisation des ressources en particulier quand le gestionnaire est instancié fréquemment. Ainsi dans le cas où on implémente le gestionnaire sous la forme d’une classe, chaque instanciation va créer un objet dans le tas managé. En cas d’utilisation fréquente, le garbage collector pourrait être sollicité de façon répétée pour traiter les instances du gestionnaire à disposer.
Une optimisation permettant d’éviter des sollicitations du garbage collector serait d’utiliser une structure. En effet les structures étant, la plupart du temps, instanciées sur la pile, elles évitent une utilisation du garage collector en cas d’instanciation répétée.

Pour aller plus loin, on peut utiliser une ref struct qui va garantir que le structure ne peut être utilisée que sur la pile. En effet, apparu en C# 7.2, ref peut être utilisé quand on déclare un objet struct pour indiquer qu’une instance de la structure ne peut se trouver que dans la pile et ne pourra pas correspondre à une allocation dans le tas managé.

Dans le cadre de notre exemple, on peut modifier l’implémentation en utilisant une ref struct plutôt qu’une classe:

public ref struct PointStringFormatter
{
    ...
}

Attribut InterpolatedStringHandlerArgument

Dans le cas précédent, l’instanciation du gestionnaire de chaîne de caractères à interpoler a été effectuée juste avec un argument qui est la chaîne à interpoler. On peut ajouter des arguments lors de l’instanciation du gestionnaire en utilisant l’attribut InterpolatedStringHandlerArgumentAttribute.

Pour rappel, on peut instancier un gestionnaire:

  • Directement à partir d’une chaîne de caractères interpolées: 
    PointStringFormatter pointFormatter = $"{nameof(point1)}: {point1} / {nameof(point2)}: {point2}";
  • Dans l’argument d’une méthode: par exemple si on définit une méthode avec un gestionnaire de cette façon: 
    public void ShowPoint(PointStringFormatter point)
{
    ...
}

On peut instancier le gestionnaire en appelant la méthode avec une chaîne de caractères interpolées:

ShowPoint($"{nameof(point1)}: {point1} / {nameof(point2)}: {point2}");

C’est en utilisant cette 2e méthode, qu’il est possible d’utiliser l’attribut InterpolatedStringHandlerArgument pour instancier le gestionnaire avec des arguments supplémentaires. Ainsi on considère une méthode avec plusieurs arguments en plus du gestionnaire, on utilise le attribut InterpolatedStringHandlerArgument pour indiquer quels sont les arguments à utiliser pour instancier le gestionnaire.

Par exemple, si on considère le gestionnaire PointStringFormatterV2 avec un constructeur avec 2 arguments supplémentaires par rapport à PointStringFormatter:

public ref struct PointStringFormatterV2
{
    public PointStringFormatterV2(int literalLength, int formattedCount, string formattingPrefix, string formattingSuffix)
    {
        // ...
    }

    // ...
}

On définit la méthode suivante en ajoutant les arguments formattingPrefix et formattingSuffix. Puis on indique dans l’attribut InterpolatedStringHandlerArgument les arguments à utiliser pour instancier le gestionnaire:


public void ShowPoint(string formattingPrefix, string formattingSuffix, 
    [InterpolatedStringHandlerArgument("formattingPrefix", "formattingSuffix")] PointStringFormatterV2 point)
{
    // ...
}

Ainsi si on appelle ShowPoint() de cette façon:

ShowPoint("(", ")", $"{nameof(point1)}: {point1}");

Le constructeur du gestionnaire PointStringFormatterV2 sera instancié en utilisant les arguments formattingPrefix et formattingSuffix ayant respectivement les valeurs "(" et ")".

Dans le cadre de cet exemple, l’implémentation de PointStringFormatterV2 est:

[InterpolatedStringHandler]
public class PointStringFormatterV2
{
    private StringBuilder builder;
    private string formattingPrefix;
    private string formattingSuffix;

    public PointStringFormatterV2(int literalLength, int formattedCount, string formattingPrefix, string formattingSuffix)
    {
        builder = new StringBuilder(literalLength);
        this.formattingPrefix = formattingPrefix;
        this.formattingSuffix = formattingSuffix;
        Console.WriteLine($"\tliteral length: {literalLength}, formattedCount: {formattedCount}");
    }

    public void AppendLiteral(string s)
    {
        builder.Append(s);
    }

    public void AppendFormatted<T>(T t)
    {
        string pointAsString = t switch
        {
            ThreeDimensionPoint threeDimensionPoint => $"{threeDimensionPoint.X}; {threeDimensionPoint.Y}; {threeDimensionPoint.Z}",
            TwoDimensionPoint twoDimensionPoint => $"{twoDimensionPoint.X}; {twoDimensionPoint.Y}",
            null => "null",
            string formattedString => formattedString,
            _ => throw new InvalidOperationException($"{nameof(T)} is unknown")
        };
        AppendLiteral(this.formattingPrefix);
        AppendLiteral(pointAsString);
        AppendLiteral(this.formattingSuffix);
    }

    internal string GetFormattedText() => builder.ToString();
}

L’implémentation de ShowPoint() est:

public void ShowPoint(string formattingPrefix, string formattingSuffix, 
    [InterpolatedStringHandlerArgument("formattingPrefix", "formattingSuffix")] PointStringFormatterV2 point)
{
    Console.WriteLine(point.GetFormattedText());
}

Si on appelle ShowPoint() de cette façon:

var point1 = new ThreeDimensionPoint(4, 7, 9);
var point2 = new TwoDimensionPoint(4, 7);
ShowPoint("(", ")", $"{nameof(point1)}: {point1}");
ShowPoint("(", ")", $"{nameof(point2)}: {point2}");

On obtient:

literal length: 2, formattedCount: 2
(point1): (4; 7; 9)
literal length: 2, formattedCount: 2
(point2): (4; 7)

Ainsi on peut voir que l’attribut InterpolatedStringHandlerArgument a permis d’instancier PointStringFormatterV2 avec 2 arguments supplémentaires.

Références

Amélioration des informations de diagnostic sur une méthode (C# 10)

Cet article fait partie d’une série d’articles sur les apports fonctionnels de C# 10.0.

Il existe des attributs permettant d’indiquer des informations sur l’appelant d’une méthode. Avant C# 10, il existait 3 attributs:

C# 10 permet de rajouter l’attribut CallerArgumentExpressionAttribute pour indiquer sous forme d’une chaine de caractères l’expression à l’origine de la valeur d’un paramètre de la fonction courante.

Attributs de diagnostic avant C# 10

Tous ces attributs peuvent être utilisés pour apporter des informations de diagnostic sur la façon dont une méthode est appelée. Ces informations peuvent, par exemple, être logguées.

Par exemple si on considère le code suivant:

public class Example
{
  public void CallingMethod()
  {
    string calleeSecondArgument = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor...";
    int firstInteger = 9;
    int secondInteger = 610;

    this.Callee(firstInteger + secondInteger, calleeSecondArgument, true);
  }

  private void Callee(int firstArgument, string secondArgument, bool thirdArgument)
  {
    Console.WriteLine(firstArgument);
    Console.WriteLine(secondArgument);
    Console.WriteLine(thirdArgument);
  }
}

Sans surprise la valeur des 3 arguments est affichée dans la console:

619
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor...
True

Dans Callee(), on peut facilement afficher la valeur de chaque argument. Dans le but d’avoir des informations supplémentaires au moment de l’exécution, on peut utiliser les attributs indiqués précédemment sous la forme d’arguments supplémentaires de la méthode:

using System.Runtime.CompilerServices;

private void Callee(int firstArgument, string secondArgument, bool thirdArgument,
  [CallerMemberName] string memberName = "",
  [CallerFilePath] string sourceFilePath = "",
  [CallerLineNumber] int sourceLineNumber = 0)
{
  Console.WriteLine(firstArgument);
  Console.WriteLine(secondArgument);
  Console.WriteLine(thirdArgument);

  Console.WriteLine(memberName);
  Console.WriteLine(sourceFilePath);
  Console.WriteLine(sourceLineNumber);
}

Quand on rajoute les arguments avec les attributs CallerMemberName, CallerFilePath et CallerLineNumber:

  • Il est obligatoire d’ajouter une valeur par défaut si une erreur de compilation est générée,
  • L’appel de la méthode Callee() n’est pas modifié: 
    this.Callee(firstInteger + secondInteger, calleeSecondArgument, true);

Le résultat de l’exécution est:

619
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor...
True
CallingMethod
C:\MyStuff\Dev\Example\ExampleCS10\CallerExpresssionArgumentFeature.cs
19

Comme on peut le voir, les arguments avec les attributs de diagnostic ne comportent plus les valeurs par défaut mais sont interprétés par le compilateur.

Précisions sur la valeur de CallerMemberName

La valeur renvoyée par l’argument CallerMemberName change suivant la nature de la méthode appelante:

  • Dans le cas d’une méthode ou propriété: la valeur sera le nom de la méthode ou de la propriété comme on a pu le voir précédemment.
  • Dans le cas d’un constructeur: la valeur sera ".ctor", par exemple: 
    internal class Example
{
  public Example()
  {
    this.Callee();
  }

  private void Callee([CallerMemberName] string memberName = "")
  {
    Console.WriteLine(memberName);
  }
}

    Le résultat est:

    .ctor
  • Dans le cas d’un constructeur statique: ".cctor", par exemple: 
    internal class Example
{
  static Example()
  {
    var example = new Example();
    example.Callee();
  }

  private void Callee([CallerMemberName] string memberName = "")
  {
    Console.WriteLine(memberName);
  }
}

    Le résultat est:

    .cctor
  • Pour une surcharge d’opérateur: la valeur sera du type "op_<nom de l'opérateur>", par exemple: 
    internal class Example
{
  public static Example operator +(Example a) => a.Callee();

  private Example Callee([CallerMemberName] string memberName = "")
  {
    Console.WriteLine(memberName);
    return this;
  }
}

    On peut appeler la surcharge de l’opérateur en exécutant:

    var example = new Example();
Console.WriteLine(+classToExecute);

    On obtient:

    op_UnaryPlus
  • Dans le corps du finalizer: la valeur sera "Finalize".

    Le plus compliqué est d’avoir un exemple permettant d’exécuter le finalizer:

    internal class CallerMemberNameFeature: IDisposable
{
  // Finalizer
  ~CallerMemberNameFeature()
  {
    this.Callee();
    Dispose(false);
  }

  public void Dispose()
  {
    GC.SuppressFinalize(this);
  }

  private void Callee([CallerMemberName] string memberName = "")
  {
    Console.WriteLine(memberName);
  }
}

    Pour exécuter:

    static void Main(string[] args)
{
  var example = new CallerMemberNameFeature();
  MyMethod(1);
  example.Dispose();
  GC.Collect();
  GC.WaitForPendingFinalizers();
}

private static void MyMethod(int i)
{
  new CallerMemberNameFeature();
}

    A l’exécution, on obtient:

    Finalize

CallerArgumentExpression

C# 10

L’attribut CallerArgumentExpressionAttribute apparu en C# 10 permet de renvoyer l’expression à l’origine de la valeur du paramètre de fonction pour lequel l’attribut est utilisé.

Si on considère l’exemple suivant:

internal class CallerExpressionArgumentFeature
{
  public void CallingMethod()
  {
    string calleeSecondArgument = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor...";
    int firstInteger = 9;
    int secondInteger = 610;
     
    this.Callee(firstInteger + secondInteger, 
    string.Format($"{0} {1} {2}", calleeSecondArgument, firstInteger, secondInteger));
  }

  private void Callee(int argument1, string argument2, 
    [CallerArgumentExpression("argument1")] string argumentExpression = "")
  {
    Console.WriteLine(argumentExpression);
  }
}

Dans cet exemple, le paramètre argumentExpression de la méthode Callee() comporte un attribut CallerArgumentExpression("argument1") indiquant que le paramètre doit contenir l’expression à l’origine de la valeur de l’argument argument1.

L’argument comportant l’attribut CallerArgumentExpression doit obligatoirement comporter une valeur par défaut.

En appelant la méthode CallingMethod():

var example = new CallerExpressionArgumentFeature();
example.CallingMethod();

On obtient:

firstInteger + secondInteger

Cette expression se trouve dans l’appel de la méthode Callee() dans CallingMethod():

this.Callee(firstInteger + secondInteger, 
  string.Format($"{0} {1} {2}", calleeSecondArgument, firstInteger, secondInteger));

De même si on modifie l’implémentation de Callee() de cette façon:

private void Callee(int argument1, string argument2, 
  [CallerArgumentExpression("argument1")] string argument1Expression = "",
  [CallerArgumentExpression("argument2")] string argument2Expression = "")
{
  Console.WriteLine(argument1Expression);
  Console.WriteLine(argument2Expression);
}

On peut obtenir l’expression à l’origine de la valeur de l’argument argument2 de Callee(). A l’exécution, on obtient:

firstInteger + secondInteger
string.Format($"{0} {1} {2}", calleeSecondArgument, firstInteger, secondInteger)

Obtenir l’expression à l’origine des valeurs des arguments peut être intéressant à logguer, par exemple, dans le cas où la valeur n’est pas celle attendue.

Références

Amélioration des structures (C# 10, C# 11)

Le but de cet article est d’indiquer les améliorations faites sur les objets structures (i.e. struct) en C# 10 et C# 11.

Sommaire

Rappels concernant les objets de type valeur
Caractéristiques des objets de type valeur
Caractéristiques des objets struct
Code MSIL

Avant C# 10.0
readonly struct
ref struct
readonly ref struct
ref struct et readonly ref struct disposable

Amélioration des structs en C# 10 et C# 11
Constructeur sans paramètre
Initialisation des membres ou propriétés directement lors de leur déclaration
Utilisation de with avec des structs
L’initialisation explicite des membres n’est plus obligatoire

Dans un 1er temps, on rappelle les caractéristiques des structs. Ensuite, on indique quelles ont été les améliorations apportées aux structs par C# 10 et C# 11.

Rappels concernant les objets de type valeur

D’une façon générale, les types d’objet en C# peuvent être séparés en 2 familles:

  • Les objets de type référence: les variables d’objets de type référence contiennent des références vers les objets en mémoire. Ces variables contenant les références sont objets de type valeur. Ainsi lorsqu’on effectue une affectation d’une variable d’un objet de type référence vers une autre variable, la référence est dupliquée et copiée dans la nouvelle variable toutefois l’objet référencé n’est pas dupliqué.
    Parmi les objets de type référence, on peut trouver les classes, les interfaces, les tableaux, le type delegate et le type dynamic. Les objets de type référence dérivent de System.Object.
  • Les objets de type valeur: les variables d’objets de type valeur correspondent à la représentation de la valeur réelle de l’objet. L’affectation d’une variable d’un objet de type valeur vers une autre variable effectue une copie de la représentation de la valeur de l’objet.
    Les objets de type valeur sont les structs et les enums. Parmi les structs, on peut citer les tuples, booléens, les types intégrals (sbyte, byte, short, ushort, int, uint, long, ulong et char), les types à virgule flottante (float ou double) et decimal. Les objets de type valeur dérivent de System.ValueType qui dérive de System.Object.

Caractéristiques des objets de type valeur

Les caractéristiques essentielles des objets de type valeur sont qu’en tant que représentation de la valeur d’un objet, ils ne sont jamais nuls et les affectations de variables effectuent des copies des objets par valeur. Ainsi tous ces objets possèdent un constructeur par défaut qui va effectuer une initialisation à zéro des différentes données membres que constituent l’objet de type valeur. Si ce constructeur n’est pas explicitement implémenté, il est rajouté par le compilateur.

L’initialisation à zéro consiste à affecter:

  • 0 aux membres de type intégral, 0.0f aux float, 0.0d aux double, 0m aux decimal,
  • false aux objets bool,
  • null aux objets de type référence,
  • Initialiser à zéro les membres de type valeur.

Caractéristiques des objets struct

En plus des caractéristiques des objets de type valeur, une struct ne peut pas être statique, ne peut pas hériter d’une autre struct et ne peut pas être abstraite. Une struct peut satisfaire une interface et peut avoir des membres statiques.

Ainsi, si on considère:

internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;
}

internal class ClassExample { }

Alors:

var structExample = new StructExample();
Console.WriteLine(structExample.IntegerMember);  // 0
Console.WriteLine(structExample.StringMember);   // null
Console.WriteLine(structExample.ClassMember);    // null

Cette implémentation ne génère pas d’erreurs toutefois des warnings indiquent que les membres ne sont jamais initialisés:

warning CS0649: Field 'StructExample.StringMember' is never assigned to, and will always have its default value null
warning CS0649: Field 'StructExample.ClassMember' is never assigned to, and will always have its default value null
warning CS0649: Field 'StructExample.IntegerMember' is never assigned to, and will always have its default value 0

Les warnings disparaissent si on initialise les membres:

var structExample = new StructExample { IntegerMember = 0, StringMember = string.Empty, ClassMember = new ClassExample() };

Concernant les autres caractéristiques des structs:

internal abstract struct StructExample {}  // ⚠ Erreur de compilation ⚠

internal static struct StructExample {}  // ⚠ Erreur de compilation ⚠

internal struct OtherStruct {} 
internal struct StructExample: OtherStruct {}  // ⚠ Erreur de compilation ⚠

Mais:

internal interface IExample {} 
internal struct StructExample: IExample {}  // OK

Les structures ne peuvent pas contenir de destructeurs:

internal struct StructExample
{
  ~StructExample() {} // ⚠ Erreur de compilation ⚠
}

Code MSIL

Du coté du code MSIL, les différences ne sont pas très grandes entre les classes et les structs. Si on considère les 2 objets suivants dont les implémentations sont volontairement très proches:

internal struct StructExample
{
  public int IntegerMember;

  public StructExample(int integerMember)
  {
    this.IntegerMember = integerMember;
  }
}

Et:

internal class ClassExample
{
  public int IntegerMember;

  public ClassExample(int integerMember)
  {
    this.IntegerMember = integerMember;  
  }
}

Si on regarde le code MSIL correspondant à ces 2 objets:

.class private sequential ansi sealed beforefieldinit CS10_Tests.StructExample
    extends [System.Runtime]System.ValueType
{
  .field public int32 IntegerMember

  .method public hidebysig specialname rtspecialname 
      instance void  .ctor(int32 integerMember) cil managed
  {
    // Code size     8 (0x8)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  ldarg.1
    IL_0002:  stfld    int32 CS10_Tests.StructExample::IntegerMember
    IL_0007:  ret
  } 
}

Et:

.class private auto ansi beforefieldinit CS10_Tests.ClassExample
    extends [System.Runtime]System.Object
{
  .field public int32 IntegerMember 

  .method public hidebysig specialname rtspecialname 
      instance void  .ctor(int32 integerMember) cil managed
  {
    // Code size     14 (0xe)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call     instance void [System.Runtime]System.Object::.ctor()
    IL_0006:  ldarg.0
    IL_0007:  ldarg.1
    IL_0008:  stfld    int32 CS10_Tests.ClassExample::IntegerMember
    IL_000d:  ret
  } 
}

On remarque que le type sous-jacent des objets est le même: .class. La plus grande différence réside dans l’héritage à:

  • System.ValueType dans le cas de la struct: 
    .class private sequential ansi sealed beforefieldinit CS10_Tests.StructExample
  extends [System.Runtime]System.ValueType
  • System.Object dans le cas de la classe: 
    .class private auto ansi beforefieldinit CS10_Tests.ClassExample
  extends [System.Runtime]System.Object

Ensuite:

  • sealed dans le cas de la struct qui interdit l’héritage.
  • auto dans le cas de la classe qui permet au compilateur de réordonner les membres de l’objet pour réduire les “espaces morts” entre membres occupant un espace différent en mémoire.
  • sequential dans le cas de la struct pour indiquer que les membres de l’objet sont disposés séquentiellement dans l’ordre de définition.

Dans le constructeur, un appel est effectué dans le cas de la classe au constructeur de System.Object:

IL_0001:  call     instance void [System.Runtime]System.Object::.ctor()

Si on utilise ces 2 objets de cette façon:

var structExample = new StructExample(10);
Console.WriteLine(structExample.IntegerMember);

var classExample = new ClassExample(10);
Console.WriteLine(classExample.IntegerMember);

Le code MSIL correspondant est:

// Code size     35 (0x23)
.maxstack  8
IL_0000:  ldc.i4.s   10
IL_0002:  newobj   instance void CS10_Tests.StructExample::.ctor(int32)
IL_0007:  ldfld    int32 CS10_Tests.StructExample::IntegerMember
IL_000c:  call     void [System.Console]System.Console::WriteLine(int32)
IL_0011:  ldc.i4.s   10
IL_0013:  newobj   instance void CS10_Tests.ClassExample::.ctor(int32)
IL_0018:  ldfld    int32 CS10_Tests.ClassExample::IntegerMember
IL_001d:  call     void [System.Console]System.Console::WriteLine(int32)
IL_0022:  ret

On peut remarquer que pour l’instanciation de la struct ou de la classe, le même opérateur newobj est utilisé. Newobj est, en effet, utilisé dans le cas d’un objet de type référence ou d’un objet de type valeur.
On peut donc constater que le code MSIL généré est très semblable entre une classe et une struct.

Si on modifie l’implémentation de cette façon:

StructExample structExample;  // Une struct n'est pas null donc cette construction est possible
structExample.IntegerMember = 10;
Console.WriteLine(structExample.IntegerMember);

ClassExample classExample = new ClassExample(10);
Console.WriteLine(classExample.IntegerMember);

Le code MSIL est sensiblement différent et reflète la construction de la struct spécifique aux objets de type valeur. Cette construction n’est pas possible dans le cas de la classe:

// Code size     38 (0x26)
.maxstack  2
.locals init (valuetype CS10_Tests.StructExample V_0)
IL_0000:  ldloca.s   V_0
IL_0002:  ldc.i4.s   10
IL_0004:  stfld    int32 CS10_Tests.StructExample::IntegerMember
IL_0009:  ldloc.0
IL_000a:  ldfld    int32 CS10_Tests.StructExample::IntegerMember
IL_000f:  call     void [System.Console]System.Console::WriteLine(int32)
IL_0014:  ldc.i4.s   10
IL_0016:  newobj   instance void CS10_Tests.ClassExample::.ctor(int32)
IL_001b:  ldfld    int32 CS10_Tests.ClassExample::IntegerMember
IL_0020:  call     void [System.Console]System.Console::WriteLine(int32)
IL_0025:  ret

Dans le cas de la struct, newobj n’est pas utilisé mais une variable locale est déclarée et directement initialisée:

.locals init (valuetype CS10_Tests.StructExample V_0)

Comme l’objet est de type valeur, il n’est pas nul. La variable locale correspondant à l’objet est sur la pile avec:

IL_0000:  ldloca.s   V_0

Dans le cas de la classe, le constructeur est appelé et l’opérateur newobj renvoie la référence vers la pile.

Avant C# 10.0

De façon à ce que les membres d’une structure soient initialisés à zéro à l’initialisation, certaines restrictions étaient appliquées aux structures. En cas d’absence de constructeur, le compilateur ne faisait que rajouter un constructeur permettant d’initialiser à zéro les membres de la structure. Toutes les autres formes d’implémentation du constructeur où tous les membres ne sont pas initialisés, menaient à une erreur de compilation:

  • Il n’était pas possible d’implémenter un constructeur sans paramètre: 
    internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;

  public StructExample() {}  // ⚠ Erreur avant C# 10.0 ⚠
}
  • Les initialisations de membres au même niveau que leur déclaration n’étaient pas possible: 
    internal struct StructExample
{
  public int IntegerMember = 0;  // ⚠ Erreur avant C# 10.0 ⚠
  public string StringMember = string.Empty;
  public ClassExample ClassMember = null;
}
  • Le constructeur doit initialiser toutes les données membres: 
    internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;

  // Il n'est pas nécessaire que le constructeur 
  // contienne des paramètres pour tous les membres
  public StructExample(int integerMember)
  {
    IntegerMember = integerMember;
    // StringMember = string.Empty;       // ⚠ Erreur, membre non initialisé ⚠
    // ClassMember = new ClassExample();  // ⚠ Erreur, membre non initialisé ⚠
  }
}

readonly struct

C# 7.2

Historiquement le mot-clé readonly pouvait être utilisé pour indiquer qu’un membre d’une classe ou d’une structure ne peut être initialisé que par un initializer (avant l’exécution du constructeur) ou par le constructeur.

A partir de C# 7.2, le mot-clé readonly peut être placé devant struct de façon à indiquer au compilateur que la structure doit être immutable. Par suite le compilateur vérifiera que les membres de la structure ne peuvent pas être modifiés:

  • Une propriété ne pourra pas avoir d’accesseurs en écriture: 
    public readonly struct MyStruct  
{  
  public int WritableProp { get; set; } // ERREUR  

  public int ReadOnlyProp { get; } // OK  
}
  • Les variables membres publiques doivent utiliser le mot-clé readonly: 
    public readonly struct MyStruct  
{  
  public int WritableMember; // ERREUR  

  public readonly int ReadOnlyMember; // OK  
}
  • La déclaration d’évènements dans la structure n’est pas autorisée: 
    public readonly struct MyStruct  
{  
  public event EventHandler Event; // ERREUR  
}

Ainsi la syntaxe permet de garantir que la structure est immutable.

Pour davantage de détails, voir cdiese.fr/csharp7-ref-struct/.

ref struct

C# 7.2

ref peut être utilisé quand on déclare un objet struct pour indiquer qu’une instance de la structure ne peut se trouver que dans la pile et ne pourra pas correspondre à une allocation dans le tas managé, par exemple: 

ref struct StackOnlyStruct  
{ ... }

Pour davantage de détails, voir Structure exclusivement stockée dans la pile: “ref struct” (C# 7, C# 8.0).

readonly ref struct

C# 7.2

On peut utiliser à la fois readonly et ref devant struct pour cumuler les caractéristiques de ref struct et readonly struct:

  • ref struct pour contraindre une structure à être stockée exclusivement sur la pile et
  • readonly struct pour rendre une structure immutable.

Quand on déclare la structure, le mot-clé readonly doit se trouver obligatoirement avant ref:

readonly ref struct ImmutableStackOnlyStruct  
{ ... }

Pour davantage de détails, voir cdiese.fr/csharp7-ref-struct/#cs7-ref_readonly_struct-readonly_ref_struct.

ref struct et readonly ref struct disposable

C# 8.0

A partir de C# 8.0, les structures de type ref struct ou readonly ref struct peuvent être disposable. Sachant que les ref struct et les readonly ref struct sont stockées seulement sur la pile, il n’est pas possible de les faire satisfaire une interface, on ne peut donc pas implémenter IDisposable. A partir de C# 8.0, si une ref struct ou une readonly ref struct implémente une méthode publique void Dispose() alors la structure sera disposable sans avoir à rajouter explicitement : IDisposable.

Par exemple, si on considère la structure suivante:

ref struct DisposableStruct
{
  public Dispose()
  {
    Console.WriteLine("Disposed");
  }
}

En exécutant le code suivant, la méthode Dispose() est bien exécutée:

using (new DisposableStruct())
{
}

Pour davantage de détails, voir cdiese.fr/csharp7-ref-struct/#cs7-ref_readonly_struct-readonly_ref_struct_disposable.

Amélioration des structs en C# 10 et C# 11

De façon à rendre les structs moins contraignantes à utiliser et de les rapprocher des fonctionnalités de classes, quelques améliorations ont été apportées:

  • A partir de C# 10:
    • Il est désormais possible de déclarer un constructeur sans paramètre.
    • L'initialisation d'un membre ou d'une propriété est possible directement au niveau de se déclaration.
    • On peut utiliser l'opérateur with avec des structs.
  • A partir de C# 11, il n'est plus nécessaire que le constructeur initialise tous les membres.

Constructeur sans paramètre

C# 10

A partir de C# 10, il n'est plus obligatoire d'utiliser un constructeur avec au moins un paramètre. On peut désormais implémenter un constructeur sans paramètre toutefois il est obligatoire d'initialiser tous les membres en C# 10 (cette obligation n'est plus valable avec C# 11). Si les membres ne sont pas initialisés explicitement, des erreurs de compilation sont générées:

internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;

  public StructExample()
  {
    // ⚠ ERREUR en C# 10 ⚠
  }
}

Erreurs de compilation si les membres ne sont pas explicitement initialisés: 

error CS0171: Field 'StructExample.IntegerMember' must be fully assigned before control is returned to the caller. 
error CS0171: Field 'StructExample.StringMember' must be fully assigned before control is returned to the caller. 
error CS0171: Field 'StructExample.ClassMember' must be fully assigned before control is returned to the caller.

Si on initialise tous les membres:

internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;

  public StructExample()
  {
     IntegerMember = 0;
     StringMember = string.Empty;
     ClassMember = new ClassExample();    
  }
}

L'obligation d'initialiser explicitement les membres disparait avec C# 11.

Initialisation des membres ou propriétés directement lors de leur déclaration

C# 10

Désormais il est possible d'initialiser des membres et des propriétés d'une struct lors de leur déclaration. Lorsqu'au moins un membre est initialisé lors de sa déclaration, un constructeur explicite est requis sinon une erreur de compilation est générée (cette obligation ne s'applique pas pour une propriété):

internal struct StructExample
{
   public int IntegerMember = 0; // ⚠ ERREUR ⚠: au moins un constructeur est requis
}

Cette implémentation entraîne une erreur à la compilation:

error CS8983: A 'struct' with field initializers must include an explicitly declared constructor.

L'implémentation d'un constructeur sans paramètre suffit:

internal struct StructExample
{
  // Membres
  private ClassExample classExample = new ClassExample();

  public int IntegerMember = 0;
  public string StringMember = string.Empty;


  // Constructeur sans paramètre
  public StructExample() {}

  // Propriété
   public ClassExample ClassMember => this.classExample;
}

Utilisation de with avec des structs

C# 10

Si on considère la struct:

internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
}

On peut utiliser l'opérateur with (introduit en C# 9) pour construire une autre instance d'une struct en se basant sur la 1ère instance:

var firstExample = new StructExample { IntegerMember = 10, StringMember = "First" };
var secondExample = firstExample with { StringMember = "Second" };

Console.WriteLine(secondExample.IntegerMember);  // 10
Console.WriteLine(secondExample.StringMember);   // Second

L'objet généré par l'opérateur with (cf. secondExample) possède des membres avec les mêmes valeurs que l'objet à gauche de l'opérateur (cf. firstExample) à l'exception des membres dont on modifie explicitement la valeur (comme StringMember):

10 
Second

L'initialisation explicite des membres n'est plus obligatoire

C# 11

A partir de C# 11, il n'est plus nécessaire d'initialiser tous les membres dans le constructeur. Dans le cas où les membres ne sont pas initialisés explicitement, ils sont initialisés à zéro (comme dans le cas où il n'y a pas de constructeur):

internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;

  public StructExample() { }
}

Cette implémentation ne générera pas d'erreurs à la compilation toutefois des warnings seront générés car les membres ne sont pas initialisés:

warning CS0649: Field 'StructExample.StringMember' is never assigned to, and will always have its default value null
warning CS0649: Field 'StructExample.ClassMember' is never assigned to, and will always have its default value null
warning CS0649: Field 'StructExample.IntegerMember' is never assigned to, and will always have its default value 0

Les membres sont initialisés à zéro (comme dans le cas d'une absence de constructeur):

var structExample = new StructExample();
Console.WriteLine(structExample.IntegerMember);   // 0 
Console.WriteLine(structExample.StringMember);    // null
Console.WriteLine(structExample.ClassMember);     // null

En initialisant les membres, les warnings disparaissent:

internal struct StructExample
{
  public int IntegerMember;
  public string StringMember;
  public ClassExample ClassMember;

  public StructExample()
  {
    this.ClassMember = new ClassExample();
    this.StringMember = string.Empty;
    this.IntegerMember = 0;
  }
}

Références

Compatibilité entre le framework .NET historique et .NET


Actuellement, 2 implémentations de .NET peuvent être utilisées:

  • l’implémentation historique du Framework .NET toujours supportée mais dont la version s’arrête à la version majeure 4.8 (actuellement 4.8.1).
  • l’implémentation actuelle .NET anciennement appelée .NET Core jusqu’à la version 3.1 (cf. dotnet.microsoft.com/en-us/download/dotnet).

Le framework .NET existant depuis les années 2000, beaucoup d’applications existent toujours en ayant comme cible le framework historique. Même si la grande majorité des fonctionnalités existent entre le framework .NET et .NET, le passage d’un framework à l’autre est loin d’être trivial. Des solutions existent pour limiter la quantité de code ciblant le framework .NET comme par exemple utiliser .NET Standard. En effet, .NET Standard permet ainsi d’avoir du code utilisable à la fois par des applications ciblant le framework .NET et .NET. Toutefois, de la même façon le passage du code du framework .NET à .NET Standard est loin d’être trivial.

Ainsi dans le but de ne pas avoir à trop migrer du code “legacy”, on peut se poser la question de savoir quelles sont les compatibilités entre le framework .NET historique et l’implémentation plus actuelle de .NET.

Le but de cet article est d’étudier en détails les différences entre le framework .NET et .NET et vérifier quels sont les éléments de compatibilité entre les 2:

  • Quelles sont les différences entre une assembly ciblant le framework .NET et une assembly ciblant .NET sous Windows ?
  • Une assembly ciblant framework .NET peut-elle être utilisée directement dans une application .NET ? Et inversement ?
  • Est-on obligé d’utiliser .NET Standard pour avoir des assemblies communes entre le framework .NET et .NET ?
Dans cet article

Fonctionnement générale de .NET
Historique de .NET
  Framework .NET historique
  .NET Core
  .NET

Fonctionnement général du CLR
  Chargement des assemblies à la demande
  Démarrage d’une application .NET
  Chargement des dépendances
  AssemblyLoadContext
  Recherche par défaut des assemblies

Redirection de type
  TypeForwardedFrom

Différences de dépendances entre le framework .NET historique et .NET
Structure d’une assembly
  PE Header
  Module
  Assembly
  Code MSIL

Comparaison entre des assemblies ciblant différents frameworks

Equivalences entre le framework .NET historique et .NET
.NET Standard
  Exemple d’utilisation de .NET Standard
Compatibility shim
  Utiliser des assemblies framework .NET dans une application ciblant .NET
  Utiliser des assemblies .NET dans une application framework .NET

Conclusion

.NET et .NET 🤯

Dans cet article pour éviter les confusions, on emploiera les termes:

  • “Framework .NET historique” pour désigner le framework .NET dont la version s’arrête à 4.8.x.
  • “.NET” pour désigner l’implémentation actuelle de .NET (anciennement appelée .NET Core).

Dans un premier temps, on va indiquer quelles sont les différences les plus importantes entre une application ciblant le framework .NET historique et la même application ciblant .NET. Ensuite, on va montrer quelles sont les possibilités pour utiliser des assemblies communes sans forcément utiliser .NET Standard.

Fonctionnement générale de .NET

Avant tout, le but de cette partie est de décrire le fonctionnement générale de .NET suivant les 2 implémentations.

Historique de .NET

Framework .NET historique

Historiquement le framework .NET historique a été construit au dessus de Windows ce qui le rend très spécifique à cette plateforme. On peut, toutefois, distinguer 2 types de dépendances sur lesquelles repose une application ciblant le framework .NET historique:

  • Les dépendances systèmes: ensemble de DLL Windows permettant à l’application de s’interfacer avec le système d’exploitation et plus généralement la machine, par exemple: advapi32.dll, kernel32.dll, gdi32.dll etc… (on peut trouver une liste plus exhautive sur Microsoft Windows library files).
  • Le framework .NET historique: avant Windows 10, le framework était distribué de façon séparé du système d’exploitation (cf. dotnet.microsoft.com/en-us/download/dotnet-framework). Il fallait donc l’installer séparément. Depuis Windows 10, le framework fait partie du système d’exploitation et est distribué en même temps sans installation séparée. On peut toutefois considérer les DLL et assemblies du framework .NET historique séparément des DLL système. L’assembly la plus connue faisant partie de cette catégorie est mscorlib.dll.

Historiquement et en particulier avant Nuget (apparu avec le framework 4.0), une application ciblant le framework .NET historique était distribuée sans aucune assembly du framework, seul le code et les assemblies fonctionnelles étaient fournis. De façon à rendre une application moins dépendante de la version du framework installée sur une machine, lors de l’implémentation d’une application, certaines dépendances du framework pouvaient être téléchargées via Nuget à partir du framework 4.0. Ainsi, on peut trouver des packages Nuget comme System.Runtime, System.IO, System.IO.FileSystem etc… Les assemblies dans ces packages sont déployées au même moment que l’application ce qui permet de rendre l’application moins dépendante des assemblies .NET du système d’exploitation.

Le framework .NET historique est toujours supporté toutefois il ne bénéficie plus plus d’évolutions fonctionnelles notables. La dernière version est 4.8.1. Il existe des compatibilités de code avec .NET Core.

.NET Core

L’implémentation .NET Core a commencé en 2016 de la version .NET Core 1.0 jusqu’à la version 3.1. Cette implémentation continue actuellement sous l’appellation .NET. Le plus gros avantage de cette implémentation est qu’elle n’est pas dépendante de la plateforme Windows à l’inverse du framework .NET historique. A la compilation, il est possible de cibler d’autres systèmes d’exploitation comme Linux ou Mac OS. De plus, il est possible de déployer une application .NET Core de façon autonome avec toutes les dépendances dans le même répertoire ce qui limite d’éventuel problème de dépendances non satisfaites à l’exécution.

Au fur et à mesure des versions de .NET Core, les fonctionnalités du framework .NET historique ont été portées sur .NET Core:

  • .NET Core 1.0: portage des fonctionnalités principales du framework .NET historique avec la CoreCLR et la machine virtuelle permettant l’exécution des application .NET.
  • .NET Core 2.0: supporte .NET Standard 2.0. Beaucoup de fonctionnalités sont rajoutés au .NET Standard 2.0 et donc de fait sont rajoutées dans .NET Core 2.0 comme ASP.NET Core 2.0, Entity Framework Core 2.0, Razor Pages, SignalR.
  • .NET Core 3.0: le support de technologie desktop comme WPF ou Windows Forms est rajoutée mais réservé à une plateforme Windows. .NET Core 3.0 introduit des fonctionnalités inédites comme les Web assemblies.

La dénomination .NET Core s’est arrêtée avec la version 3.1 toutefois cette implémentation a continué sous l’appélation .NET.

.NET

Il s’agit actuellement de l’implémentation principale de la technologie .NET. L’appellation a commencé avec la version 5.0 qui est la continuation de .NET Core. Une très grande partie des fonctionnalités du framework .NET historique ont été portées dans .NET. Désormais, les évolutions fonctionnelles ne sont implémentées que dans cette implémentation.

Dans Visual Studio 2022, l’interface ne permet plus de créer une application du framework .NET historique sans éditer directement le fichier .csproj.

Fonctionnement général du CLR

Le but de cette partie est d’évoquer quelques caractéristiques du CLR.

Chargement des assemblies à la demande

Par défaut, le CLR fonctionne en ne chargeant que les types dont il a besoin en mode “lazy loading” c’est-à-dire seulement s’il doit appeler une méthode dans ce type.

Par exemple si on considère le code suivant:

  • Une classe QuickSort se trouvant dans une assembly nommée QuickSort.dll: 
    namespace Example
{
  public class QuickSort
  {
    public QuickSort(int numberCount)
    {
      // ...
    }

    public IReadOnlyList<int> OriginalNumbers => this.originalNumbers;
    public IReadOnlyList<int> Sort()
    {
      // ...
    }
  }
}

    Le détail du code n’a pas d’importance, il faut juste prêter attention aux appels qui sont effectués.

  • Une classe QuickSortCaller se trouvant dans une assembly nommée Launcher.dll: 
    namespace Launcher
{
  internal class QuickSortCaller
  {
    public QuickSortCaller()
    {

    }

    public void CallQuickSort() 
    {
      var quickSort = new QuickSort(10);
      Console.WriteLine($"Original numbers: {string.Join("; ", quickSort.OriginalNumbers)}");
      var sortedNumbers = quickSort.Sort();
      Console.WriteLine($"Sorted numbers: {string.Join("; ", sortedNumbers)}");
    }
  }
}
  • Enfin le "Main" dans l’assembly Launcher.dll: 
    namespace Example.Launcher
{
  class TestClass
  {
    static void Main(string[] args)
    {
      PrintAssemblies();
      Console.ReadLine();

      var quickSortCaller = new QuickSortCaller();
      quickSortCaller.CallQuickSort();

      PrintAssemblies();
      Console.ReadLine();
    }

    public static void PrintAssemblies()
    {
      var assemblies = AppDomain.CurrentDomain.GetAssemblies();
      foreach (var assembly in assemblies)
      {
        Console.WriteLine(assembly.GetName());
      }
    }
  }
}

Le but de cette application est de lancer le tri en ordre croissant de 10 nombres par la classe QuickSort à partir de Launcher.exe. L’exécution est interrompue par des Console.ReadLine() de façon à pouvoir vérifier quelles sont les assemblies qui sont chargées en mémoire.

On se propose de monitorer le chargement des assemblies avec Process Monitor (on peut télécharger cet outil sur learn.microsoft.com/en-us/sysinternals/downloads/procmon).
On le configure en cliquant sur le filtre:

Filtrer dans Process Monitor

On applique les filtres:

  • Process Name is Launcher.exe.
  • Operation is "Load Image".

Ainsi:

  • A la 1ere exécution de Console.ReadLine(), on obtient à l’exécution: 
    C:\Users\matmanhatan2906\Dev\NetCoreVsFramework\src\QuickSort\Launcher\bin\x64\Release\net6.0\Launcher.exe
System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
Launcher, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
System.Runtime, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
System.Console, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a

    Dans Process Monitor, on obtient la liste:

    C:\Users\matmanhatan2906\Dev\NetCoreVsFramework\src\QuickSort\Launcher\bin\x64\Release\net6.0\Launcher.exe
C:\Windows\System32\ntdll.dll
C:\Windows\System32\kernel32.dll
C:\Windows\System32\KernelBase.dll
C:\Windows\System32\user32.dll
C:\Windows\System32\win32u.dll
C:\Windows\System32\gdi32.dll
C:\Windows\System32\gdi32full.dll
C:\Windows\System32\msvcp_win.dll
C:\Windows\System32\ucrtbase.dll
C:\Windows\System32\shell32.dll
C:\Windows\System32\advapi32.dll
C:\Windows\System32\msvcrt.dll
C:\Windows\System32\sechost.dll
C:\Windows\System32\rpcrt4.dll
C:\Windows\System32\imm32.dll
C:\Program Files\dotnet\host\fxr\7.0.2\hostfxr.dll
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.13\hostpolicy.dll
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.13\coreclr.dll
C:\Windows\System32\ole32.dll
C:\Windows\System32\combase.dll
C:\Windows\System32\oleaut32.dll
C:\Windows\System32\bcryptprimitives.dll
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.13\System.Private.CoreLib.dll
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.13\clrjit.dll
C:\Users\matmanhatan2906\Dev\NetCoreVsFramework\src\QuickSort\Launcher\bin\x64\Release\net6.0\Launcher.dll
C:\Users\matmanhatan2906\Dev\NetCoreVsFramework\src\QuickSort\Launcher\bin\x64\Release\net6.0\Launcher.dll
C:\Windows\System32\kernel.appcore.dll
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.13\System.Console.dll
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.13\System.Threading.dll
  • A la 2e exécution de Console.ReadLine(), on obtient à l’exécution: 
    Original numbers: 417669634; 1956917617; 711754152; 278682087; 1764089466; 1626660450; 907923799; 1181956495; 1884345336; 1655709668
Sorted numbers: 278682087; 417669634; 711754152; 907923799; 1181956495; 1626660450; 1655709668; 1764089466; 1884345336; 1956917617
System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
Launcher, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
System.Runtime, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
System.Console, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
System.Threading, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
System.Text.Encoding.Extensions, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
QuickSort, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Dans Process Monitor, les lignes suivantes sont rajoutées:

C:\Users\matmanhatan2906\Dev\NetCoreVsFramework\src\QuickSort\Launcher\bin\x64\Release\net6.0\QuickSort.dll
C:\Windows\System32\bcrypt.dll

Ainsi on peut voir que le chargement de l’assembly QuickSort.dll ne s’est fait que lorsqu’il y a eu un appel à une fonction se trouvant dans cette assembly.

Démarrage d’une application .NET

Le démarrage d’une application .NET ne suit pas tout à fait le même ordre dans le cas du framework .NET historique et de .NET:

  • Dans le cas du framework .NET historique, l’application est un exécutable (i.e. fichier .exe) qui ne peut être lancé que sur Windows. Le format de ce fichier correspond à un Portable Executable qui sera reconnu par le système d’exploitation. Ce fichier contient une petite partie de code natif qui sert d’amorce pour démarrer le CLR par l’intermédiaire de mscoree.dll. Toutes les dépendances principales du framework dans mscorlib.dll sont ensuite chargées. Le code .NET se trouve sous la forme de code IL que le CLR va compiler en code machine par l’intermédiaire du compilateur JIT. Le premier module compilé et exécuté est celui correspondant à la fonction main. Suivant l’exécution, les autres parties du code seront compilées et les dépendances chargées au besoin.
  • Pour .NET, le fichier exécutable dépend du système d’exploitation qui a été ciblé lors de la compilation (i.e. runtime packs). Cet exécutable est une application hôte (i.e. “app host”) native qui va servir d’amorce pour charger et exécuter des DLL ayant des responsabilités différentes:
    • hostfxr.dll: cette DLL va sélectionner le bon runtime permettant d’exécuter l’application .NET. Ce runtime dépend du runtime ciblé au moment de la compilation, du système d’exploitation et du runtime réellement installé.
    • hostpolicy.dll: regroupe toutes les stratégies pour charger le runtime, appliquer la configuration, résoudre les dépendances de l’application et appeler le runtime pour exécuter l’application.
    • coreclr.dll: c’est le CLR qui va exécuter le code .NET. Le comportement est ensuite similaire au framework .NET historique: le code .NET sous la forme de code IL est compilé au besoin par l’intermédiaire du compilateur JIT. Ce code est ensuite exécuté.

Chargement des dépendances

Le principe général de chargement des dépendances est le même entre le framework .NET historique et .NET. On distingue les assemblies du framework et les dépendances plus spécifiques au code exécuté ne faisant pas partie du framework. Dans le cas du framework .NET historique, beaucoup de classes de base se trouvent dans mscorlib.dll qui est chargée au démarrage de l’application. Pour .NET, les classes de base se trouvent dans System.Private.CoreLib.dll et dans d’autres assemblies (comme System.Runtime, System.Threading, etc…).

En dehors des classes et des assemblies de base du framework, les dépendances sont chargées par le CLR au besoin si le code exécuté le nécessite. Ainsi si l’exécution d’une portion de code fait appel à un type se trouvant dans une dépendance, cette dépendance doit être chargée en mémoire si ce n’est pas déjà le cas. Le code IL obtenu suite à la compilation indique l’assembly à partir de laquelle ce type peut être trouvé; c’est de cette façon que le CLR, à l’exécution, peut savoir où le récupérer. Par exemple dans le cadre de l’exemple précédent, si on regarde le code IL correspondant à l’appel au code se trouvant dans l’assembly QuickSort.dll:

.method public hidebysig instance void  CallQuickSort() cil managed
{
  // Code size     76 (0x4c)
  .maxstack  3
  .locals init (class [QuickSort]Example.QuickSort V_0,
       class [System.Runtime]System.Collections.Generic.IReadOnlyList`1<int32> V_1)
 //...
}

On peut voir que le classe Example.QuickSort se trouve dans l’assembly QuickSort. A partir des metadatas dans le manifest, on peut trouver les caractéristiques de QuickSort:

.assembly extern QuickSort
{
  .ver 1:0:0:0
}

Si l’assembly est signée par nom fort, les metadatas comportent la clé publique correspondant à la signature:

.assembly extern System.Console
{
  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )
  .ver 6:0:0:0
}

Ainsi une dépendance externe est identifiée avec le nom de l’assembly, la version et éventuellement la clé publique. Ce fonctionnement est le même entre le framework .NET historique et .NET. En revanche, ce qui diffère est la façon dont les dépendances sont cherchées par le CLR. En effet, lorsque le CLR doit chercher une dépendance qui n’a jamais été chargée, une séquence est lancée pour chercher l’emplacement de cette dépendance.

Processus de recherche des assemblies avec le framework .NET historique

En plus de la version indiquée dans les metadatas du manifest du code IL, le CLR va chercher à déterminer la version de l’assembly à charger suivant des binding redirects pouvant se trouver dans:

  • Le fichier de configuration de l’application <nom exécutable>.exe.config.
  • Le fichier de stratégie de l’éditeur de l’assembly
  • Le fichier de configuration de la machine dans:
    • %windir%\Microsoft.NET\Framework\<version>\config\machine.config
    • %windir%\Microsoft.NET\Framework64\<version>\config\machine.config

Quand le CLR a déterminé la version à charger, il vérifie que l’assembly n’est pas déjà chargée. Si une version différente de l’assembly est déjà chargée, une exception de type FileLoadException est lancée. Si l’assembly possède un nom fort, il est possible d’en charger plusieurs versions (i.e. Side-by-side execution). Pour plus de détails sur la signature par nom fort, voir Signature des assemblies par nom fort en 5 min.

Si l’assembly n’a pas déjà été chargée, une recherche est faite dans le GAC (i.e. Global Assembly Cache). Si le GAC ne permet pas d’obtenir l’assembly à charger, une recherche à d’autres emplacements appelée probing est effectuée (i.e. Default probing). Par défaut cette recherche est effectuée:

  • En vérifiant s’il n’existe pas un élément de configuration <codeBase>
  • Dans le répertoire de l’application ou dans un répertoire avec le même nom que l’assembly:
    • <répertoire de l'application>\<nom assembly>.dll
    • <répertoire de l'application>\<nom assembly>\<nom assembly>.dll
    • <répertoire de l'application>\<culture>\<nom assembly>.dll
    • <répertoire de l'application>\<culture>\<nom assembly>\<nom assembly>.dll
  • Dans les répertoires se trouvant dans l’élément de configuration privatePath modifiable avec le paramètre <probing> dans le fichier de configuration ou dans le code avec AppDomainSetup.PrivateBinPath.
Débugguer la recherche de dépendances avec “fuslog”

Il est possible de débugguer cette séquence de recherche de dépendance en utilisant fuslogvw.exe.

Processus de recherche des assemblies avec .NET

Avec .NET, le chargement des dépendances est différent du mécanisme utilisé pour le framework .NET historique. Avec le framework .NET historique, il existait un AppDomain par défaut dans lequel les assemblies étaient chargées. Quand une assembly était chargée dans un AppDomain, il n’était pas possible de la décharger toutefois il était possible de décharger l’AppDomain entier. Ainsi l’AppDomain constitue une frontière qui permet, par exemple, de charger la même assembly dans des versions différentes. Les appels d’un AppDomain à l’autre se faisait par sérialisation/désérialisation d’objets.

AssemblyLoadContext

Avec .NET (à partir de la version 5), l’objet AppDomain existe toujours toutefois il n’existe qu’un seul AppDomain et il n’est pas possible d’en créer un autre:
AppDomain.CreateDomain(...) mène à une erreur. Les contextes de chargement (i.e. loader context) permettent de remplacer les AppDomains en apportant des fonctionnalités supplémentaires:

  • L’objet représentant un contexte de chargement est AssemblyLoadContext
  • Les contextes de chargement sont nommés, et il n’y a pas de contexte courant comme pour les AppDomains. On peut utiliser la fonction AssemblyLoadContext.GetLoadContext(<assembly>) pour renvoyer le contexte utilisé pour une assembly donnée.
  • Les appels d’un contexte à l’autre ne sont pas très couteux.
  • On peut toujours déchargé un contexte de chargement de façon à décharger une assembly: 
    var newLoadContext = new AssemblyLoadContext(name: <nom du contexte>, isCollectible: true);
// isCollectible à true autorise à décharger le contexte par la suite.
newLoadContext.LoadFromAssemblyPath(<chemin de l'assembly>);
// ... 
newLoadContext.Unload();
  • En dérivant de la classe AssemblyLoadContext et en surchargeant les fonctions:
    • Assembly Load(AssemblyName assemblyName) ou
    • IntPtr LoadUnmanagedDll (string unmanagedDllName)

    On peut implémenter un comportement particulier pour charger les dépendances d’une assembly (y compris les dépendances natives). On peut s’aider de la classe AssemblyDependencyResolver dans la résolution des dépendances.
    Voir albahari.com/nutshell/E8-CH18.aspx pour davantage de détails sur l’implémentation.

  • Les fonctions Assembly.Load(byte[]), Assembly.LoadFrom(filename) créent toujours un contexte de chargement séparé.
  • L’intérêt principal de AssemblyLoadContext est de proposer une isolation pour permettre de facilement choisir dans quel contexte les dépendances seront chargées et quel contexte sera utilisé pour accéder à la dépendance d’une assembly. On peut indiquer une portée avec using dans laquelle un autre contexte de chargement sera utilisé: 
    var addonLoadContext = new AssemblyLoadContext(...);
using (addonLoadContext.EnterContextualReflection())
{
  var addonAssembly = Assembly.Load(<nom de l'assembly>);
}

Recherche par défaut des assemblies

Lors de l’exécution de l’application par l’app host”, après avoir chargé l’assembly coreclr.dll et avant de donner le main au CoreCLR, “l’app host” affecte certaines propriétés pour indiquer des éléments de contexte à l’exécution:

  • TRUSTED_PLATFORM_ASSEMBLIES: liste des chemins des assemblies du framework (managées et natives).
  • APP_PATHS et APP_NI_PATHS: chemin de l’application
  • NATIVE_DLL_SEARCH_DIRECTORIES: liste des chemins des répertoires qui seront parcourus pour chercher les DLL natives.
  • PLATFORM_RESOURCE_ROOTS: liste des chemins des répertoires qui seront parcourus pour chercher les assemblies satellites (assemblies de ressources).
  • APP_CONTEXT_BASE_DIRECTORY: répertoire de base de l’application
  • APP_CONTEXT_DEPS_FILES: liste des fichiers contenant les dépendances, les données du contexte de compilation et les dépendances de compilation pour l’application.
  • FX_DEPS_FILE: liste des fichiers contenant les dépendances du framework.

La valeur de ces propriétés peut être obtenue avec:

AppContext.GetData(<nom de la propriété>);

Ces propriétés sont utilisées par le CLR pour trouver les dépendances managées ou natives lors de l’exécution de l’application. Par défaut, le contexte de chargement AssemblyLoadContext.Default parcourt les chemins indiqués dans les propriétés TRUSTED_PLATFORM_ASSEMBLIES et APP_PATHS.

Les assemblies satellites (assemblies de ressources) sont cherchées dans les répertoires indiquées par les propriétés PLATFORM_RESOURCE_ROOTS et APP_PATHS en ajoutant l’extension liée au nom de la culture:

  • <répertoire>\<culture>\<nom assembly>.dll
  • <répertoire>\<culture>\<nom assembly>\<nom assembly>.dll
Comment débugguer la recherche de dépendances ?

On peut voir des logs concernant la recherche des dépendances en affectant les variables d’environnement suivantes avant d’exécuter l’application:

  • COREHOST_TRACE=1: permet d’indiquer qu’on souhaite activer les logs.
  • COREHOST_TRACEFILE=out.txt: permet d’indiquer le fichier de sortie dans lequel on souhaite envoyer les logs.
  • COREHOST_TRACE_VERBOSITY=4: pour indiquer le niveau de logs (4 étant le maximum).

Pour ajouter ces variables lors du débug de l’application dans Visual Studio:

  1. Debug ⇒ <nom du projet> Debug Properties
  2. Rajouter les variables dans la partie Environment Variables

Dans le cas d’une exécution à la ligne de commandes, on peut créer un .bat contenant:

set COREHOST_TRACE=1
set COREHOST_TRACEFILE=out.txt
set COREHOST_TRACE_VERBOSITY=4

Launcher.exe

Redirection de type

La fonctionnalité de “type forwarding” (i.e. redirection de type) permet de déplacer un type d’une assembly à une autre sans avoir à changer les références des assemblies utilisant ce type. Cette fonctionnalité est régulièrement utilisée par Microsoft lors des changements de framework pour assurer la retrocompatibilité: par exemple lorsque des types ont été déplacés de System.Core.dll vers mscorlib.dll entre les frameworks 3.5 et 4 ou plus récemment lorsque des types de mscorlib.dll sont déplacés dans System.Private.CoreLib entre les frameworks .NET 4.8 et .NET Core.

Cette fonctionnalité utilise l’attribut TypeForwardToAttribute pour indiquer vers quelle assembly le type est transféré.

Pour illustrer, on prend l’exemple d’une application permettant d’appliquer l’algorithme “Quick sort” à une liste d’entiers. Le but n’est pas de rentrer dans les détails de l’algorithme mais d’avoir un exemple d’appel de fonctions. Ainsi:

  • L’algorithme se trouve dans une assembly nommée QuickSort: 
    namespace Example;

public class QuickSort
{
  private readonly int[] originalNumbers;
  public QuickSort(int numberCount)
  {
    this.originalNumbers = new int[numberCount];
    Random rnd = new Random();

    for (int i = 0; i < numberCount; i++)
    {
      originalNumbers[i] = rnd.Next();
    }
  }

  public IReadOnlyList<int> OriginalNumbers => this.originalNumbers;
  public IReadOnlyList<int> Sort()
  {
  // ...
  }
}
  • L’algorithme est appelé à partir d’une autre assembly nommée Launcher.exe: 
    using System;
using Launcher;

namespace Example.Launcher
{
  class TestClass
  {
    static void Main(string[] args)
    {
      var quickSort = new QuickSort(10);
      Console.WriteLine($"Original numbers: {string.Join("; ", quickSort.OriginalNumbers)}");
      var sortedNumbers = quickSort.Sort();
      Console.WriteLine($"Sorted numbers: {string.Join("; ", sortedNumbers)}");
    }
  }
}
Code source

Le code source complet de cet exemple se trouve dans le repository GitHub github.com/msoft/NetCoreVsFramework.

Pour résumer Launcher.exe appelle une classe et une fonction dans QuickSort.dll. Ainsi Launcher.exe référence QuickSort.dll. On décide de déplacer le code dans QuickSort.dll dans une autre assembly appelée NewQuickSort.dll sans changer la référence dans Launcher.exe donc:

  • On supprime le code se trouvant dans QuickSort.dll.
  • On référence l’assembly NewQuickSort.dll dans QuickSort.dll et
  • On ajoute l’attribut TypeForwardedTo() dans QuickSort.dll pour transférer le type Example.QuickSort vers NewQuickSort.dll: 
    using System.Runtime.CompilerServices;

[assembly: TypeForwardedTo(typeof(Example.QuickSort))]

namespace Example;

Le type Example.QuickSort se trouve désormais dans l’assembly NewQuickSort.dll. La référence typeof(Example.QuickSort) dans QuickSort.dll est possible car QuickSort.dll référence NewQuickSort.dll. Enfin l’assembly Launcher.exe n’est pas modifiée, elle référence uniquement QuickSort.dll et le code Example.QuickSort qui est censé s’y trouver.

A l’exécution, Launcher.exe instancie la classe Example.QuickSort à partir de la référence vers l’assembly QuickSort.dll. Le CLR charge le type directement dans l’assembly NewQuickSort.dll à cause du transfert de type de QuickSort.dll vers NewQuickSort.dll.

TypeForwardedFrom

On peut utiliser l’attribut System.Runtime.CompilerServices.TypeForwardedFromAttribute pour indiquer l’assembly à partir de laquelle un transfert de type est effectué. L’indication se fait en utilisant le nom complet de l’assembly comportant l’indication TypeForwardedTo. L’utilisation de l’attribut TypeForwardedFromAttribute est dans le but de documenter le transfert de type, il n’y a pas de traitement effectué par le CLR lorsque cet attribut est utilisé.

Dans notre exemple, on pourrait rajouter l’attribut TypeForwardedFromAttribute dans l’assembly NewQuickSort.dll pour indiquer que le transfert du type Example.QuickSort provient de l’assembly QuickSort.dll:

namespace Example;

[System.Runtime.CompilerServices.TypeForwardedFrom("QuickSort, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")]
public class QuickSort
{
  // ...
}

Différences de structure et de dépendances entre le framework .NET historique et .NET

Dans un 1er temps, on va indiquer quels sont les éléments constituant la structure d’une assembly .NET. Dans une 2e temps, on va chercher à trouver les différences de structure entre des assemblies ciblant des frameworks différents.

Structure d’une assembly

On peut se poser la question de savoir quelles sont les différences de structure des assemblies entre le framework .NET historique et .NET d’une part et les assemblies .NET ciblant Windows et ciblant Linux ou Mac OS d’autre part.

Le code .NET pouvant être exécuté est stocké dans des fichiers appelés assemblies. Ces assemblies sont composés des éléments suivants:
Les assemblies sont composées des éléments suivants:

  • PE Header: l’assembly est structurée dans un objet PE de plus bas niveau. A ce titre, il possède ce type d’en-tête.
  • Un manifest contenant une liste des références externes de l’assembly.
  • Sections contenant du code natif compilé.
  • Dans le cas d’assembly managée:
    • CLR Header: présent dans le cas d’une assembly managée. Ce sont des informations sur la version cible du framework .NET historique; éventuellement le hash pour la signature par nom fort (cf. Signature par nom fort); l’adresse dans le fichier des ressources et le point d’entrée indiquant la table des métadonnées permettant à l’assembly de s’autodécrire.
    • Liste des objets binaires utilisés dans les métadonnées.
    • Liste des chaines de caractères utilisées dans les métadonnées.
    • Liste des chaines de caractères utilisées dans le code IL (i.e. Intermediate Language).
    • Liste des GUID utilisés dans l’assembly.
    • Tables des métadonnées permettant d’indiquer des informations sur tous les types utilisés dans l’assembly.
    • Le code IL (i.e. Intermediate Language).

PE Header

Cet en-tête se trouve dans des fichiers dont le format est PE pour Portable Executable. Les fichiers contenant un en-tête PE Header sont des PE objects (i.e. objet PE). Ce format est commun pour structurer des fichiers différents comme des exécutables, des bibliothèques ou des drivers système. Il définit une structure connue du système d’exploitation pour qu’il puisse savoir où trouver des informations qui lui permettront de mapper le contenu du fichier organisé en sections à des zones en mémoire. Cette structure est indiquée dans l’en-tête du fichier (i.e. PE Header).

Le PE Header n’est pas spécifique à des assemblies .NET, il est aussi utilisé dans le cas de DLL natives.

Module

Un module est aussi un terme utilisé en managée et en non managée. Il désigne une unité de compilation contenant des métadonnées des types qu’il contient et du code compilé. Le code compilé n’est pas forcément du code machine. Il correspond à un niveau d’échelle plus élevé que les objets PE.

Un module ne peut pas être déployé seul et il ne contient pas de manifest c’est-à-dire qu’il n’indique pas quelles sont ses dépendances. Chaque module contient un seul type de code.

L’intérêt des modules est de pouvoir être utilisés indépendamment dans une unité déployable comme les assemblies.

Assembly

Une assembly est une unité déployable en opposition aux modules qui sont des unités de compilation. L’assembly peut ainsi être déployée seule. D’une façon générale, il s’agit de fichiers avec une extension .exe pour un exécutable ou .dll pour une bibliothèque de classes.

En .NET, les assemblies sont assez souples pour contenir un ou plusieurs modules, éventuellement des fichiers de ressources et des métadonnées. Les modules peuvent être compilés dans des langages différents. Il est aussi possible de merger le contenu de plusieurs assemblies dans une seule assembly.

On considère plusieurs types d’assemblies:

  • assembly managée: objet PE contenant du code managé. En .NET c’est la plus petite unité de déploiement. Dans la pratique, ces fichiers peuvent être des exécutables ou des bibliothèques de classes. Le plus souvent quand on utilise le terme assembly c’est pour désigner les assemblies managées.
  • assembly mixte: assembly .NET contenant à la fois du code managé et du code natif (cf. C++/CLI).
  • assembly native: on retrouve le terme assembly native dans la documentation Microsoft concernant WinSxS. Ce terme est ambigu car il laisse penser qu’il désigne d’assemblies .NET contenant seulement du code natif or, dans le cas de WinSxS, on parle bien de DLL natives classiques.En effet, en .NET, on distingue les assemblies (sous-entendu les assemblies managées) qui contiennent exclusivement du code managé et les assemblies mixtes contenant, à la fois du code managé et du code natif. Ainsi dans le cas où il n’y a que du code natif, le terme assembly native désigne un groupe d’une ou plusieurs DLL natives, de composant COM ou des collections de ressources, de types ou d’interfaces.
  • Side-by-side assembly: assembly native contenant une liste de ressources ou un groupe de DLL avec un manifest. Le loader du système d’exploitation utilise les informations du manifest pour identifier l’assembly et être capable de la charger quand un exécutable a une dépendance vers cette dernière. Elles ont une identité unique et sont utilisées pour éviter de casser des dépendances.
  • Private assembly: assembly native utilisée seulement par une seule application. Elle peut être inclue en tant que ressource d’une autre DLL ou installer dans le même répertoire que l’exécutable qui l’utilise.
  • Shared assembly: side-by-side assembly déployée dans le répertoire du cache des assemblies du système WinSxS. Ces assemblies peuvent être utilisées par un exécutable si la dépendance est indiquée dans son manifest.

Dans le cadre de cet article, par simplification, on ne s’intéressera qu’aux assemblies managées.

Code MSIL

En .NET, le code n’est pas directement compilé en code machine comme cela est le cas pour du code C++ natif. Le code .NET est compilé dans des assemblies contenant des instructions MSIL (pour MicroSoft Intermediate Language). Ces instructions sont exécutables par le CLR (i.e. Common Language Runtime).

Compilation avec Roslyn vs Compilation avec le JIT

A l’exécution et suivant les besoins du CLR, les instructions MSIL sont de nouveau compilées en code machine par le compilateur JIT (i.e. Just In Time). Le code machine généré est ensuite exécuté par la machine. Les instructions MSIL sont compilées à la demande, en fonction des appels qui sont effectués. Si des instructions correspondant à une fonction ne sont pas appelées alors ces instructions ne seront pas compilées par le compilateur JIT. D’autre part, le compilateur JIT effectue des optimisations dans le code généré suivant la façon dont les fonctions sont appelées. Ainsi les performances d’exécution d’un programmation peuvent s’améliorer au fur et à mesure de son exécution.

On peut trouver le terme CIL (pour Common Intermediate Language) pour désigner du code IL. Il correspond aux mêmes jeux d’instructions que le MSIL toutefois ce terme est utilisé dans le cadre du standard CLI (i.e. Common Language Infrastructure).

Comparaison entre des assemblies ciblant différents frameworks

On va considérer du code .NET simple que l’on va stocker dans une bibliothèque de classes (i.e. class library) nommée QuickSort.dll et on va cibler le framework .NET historique 4.8, .NET 6.0 sous Windows et sous Linux.

Le code correspondant à une classe dont la structure est (le code précis n’a pas d’importance mais on peut le consulter sur GitHub src/QuickSort/QuickSort/QuickSort.cs): 

namespace Example
{ 
  public class QuickSort
  {
    private readonly int[] originalNumbers;
    public QuickSort(int numberCount)
    {
      [...]
    }

    public IReadOnlyList<int> OriginalNumbers => this.originalNumbers;
    public IReadOnlyList<int> Sort()
    {
       [...]
    }
    private static void Quicksort(int[] numbers, int first, int last)
    {
      [...]
    }
  }
}
Comment générer dans Visual une assembly en ciblant le framework .NET historique 4.8 ?

Il faut éditer le fichier projet en faisant un clique droit sur le projet puis “Edit Project File” et modifier le contenu de cette façon:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>net4.8</TargetFramework>   
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>disable</Nullable>
  </PropertyGroup>
</Project>
  1. Enregistrer le fichier .csproj.
  2. Faire un clique droit sur le projet puis Publish.
  3. Sélectionner les valeurs suivantes:
    • Configuration: Release | Any CPU
    • Target Framework: net4.8
    • Target runtime: Portable
    • Target location: bin\Release\net4.8\publish\win-x64\
  4. Cliquer sur Publish

Comment générer dans Visual une assembly avec pour runtime cible linux ?

Le contenu du fichier .csproj doit permettre de cibler .NET 6.0:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>disable</Nullable>
  </PropertyGroup>
</Project>
  1. Puis faire un clique droit sur le projet puis Publish.
  2. Sélectionner les valeurs suivantes:
    • Configuration: Release | Any CPU
    • Target Framework: net6.0
    • Deployment mode: Portable
    • Target runtime: linux-x64
    • Target location: bin\Release\net6.0\publish\linux-x64\
  3. Cliquer sur Publish

Refaire la même opération avec Target runtime: win-x64 et Target location: bin\Release\net6.0\publish\win-x64\.

Les assemblies générées devraient se trouver dans les répertoires:

  • Runtime ciblant framework 4.8 pour Windows: bin\Release\net4.8\publish\win-x64\
  • Runtime ciblant .NET 6.0 pour Windows: bin\Release\net6.0\publish\win-x64\
  • Runtime ciblant .NET 6.0 pour Linux: bin\Release\net6.0\publish\linux-x64\

Si on compare les assemblies entre elles, on peut voir qu’elles ne sont pas tout à fait identiques:

  • Entre les assemblies .NET 6.0 ciblant Windows ou Linux: 
    fc /b bin\Release\net6.0\publish\linux-x64\QuickSort.dll bin\Release\net6.0\publish\win-x64\QuickSort.dll
Comparing files BIN\RELEASE\NET6.0\PUBLISH\LINUX-X64\QuickSort.dll and BIN\RELEASE\NET6.0\PUBLISH\WIN-X64\QUICKSORT.DLL
00000088: 4F AF
00000089: 7B 74
0000008A: 7D 07
0000008B: B7 8F
...
  • Entre les assemblies .NET 6.0 ciblant Windows et l’assembly ciblant le framework .NET historique 4.8, les différences sont plus importantes: 
    fc /b bin\Release\net4.8\publish\win-x64\QuickSort.dll bin\Release\net6.0\publish\win-x64\QuickSort.dll
Comparing files BIN\RELEASE\NET4.8\PUBLISH\WIN-X64\QuickSort.dll and BIN\RELEASE\NET6.0\PUBLISH\WIN-X64\QUICKSORT.DLL
00000084: 4C 64
00000085: 01 86
00000086: 03 02
00000088: 08 AF
00000089: 67 74
0000008A: FE 07
0000008B: BC 8F
[...]
FC: BIN\RELEASE\NET4.8\PUBLISH\WIN-X64\QuickSort.dll longer than BIN\RELEASE\NET6.0\PUBLISH\WIN-X64\QUICKSORT.DLL

Dans un 1er temps, on peut comparer les headers de ces fichiers avec dumpbin. Cet utilitaire permet d’afficher le PE Header de DLL. On peut obtenir cet outil en installant les “C++ profiling tools” dans la rubrique “Desktop development with C++” de l’installateur de Visual Studio. Après installation, cet outil se trouve dans un répertoire du type:
C:\Program Files\Microsoft Visual Studio\<Version VS>\Community\VC\Tools\MSVC\<Version compilateur>\bin\Hostx64\x64\dumpbin.exe.

Par exemple:

C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.34.31933\bin\Hostx64\x64\dumpbin.exe

Ainsi, si on extrait le header pour chaque DLL en exécutant à partir de l’invite de commande “Native tools Command prompt”:

dumpbin /headers <chemin de l'assembly>

En comparant les headers des différentes versions de l’assembly QuickSort.dll, on peut voir que:

  • Il n’y a pas de différences de headers entre les assemblies ciblant .NET 6.0 pour Windows ou pour Linux et
  • La seule différence notable dans le header entre une assembly ciblant .NET 6.0 et une autre assembly ciblant le framework .NET historique est dans la donnée "subsystem version":
    Extrait du header de l’assembly ciblant le framework .NET historique: Extrait du header de l’assembly ciblant .NET 6.0: 
    OPTIONAL HEADER VALUES
      20B magic # (PE32+)
      48.00 linker version
      A00 size of code
      400 size of initialized data
        0 size of uninitialized data
        0 entry point
     2000 base of code
    180000000 image base (0000000180000000 to 0000000180005FFF)
     2000 section alignment
      200 file alignment
     4.00 operating system version
     0.00 image version
     6.00 subsystem version
[...]
    		 
    OPTIONAL HEADER VALUES
      20B magic # (PE32+)
      48.00 linker version
      A00 size of code
      400 size of initialized data
        0 size of uninitialized data
        0 entry point
     2000 base of code
    180000000 image base (0000000180000000 to 0000000180005FFF)
     2000 section alignment
      200 file alignment
     4.00 operating system version
     0.00 image version
     4.00 subsystem version
[...]

Les différences se trouvent donc ailleurs.

On se propose, ensuite, de comparer les metainfos des assemblies en utilisant ildasm (cet outil se trouve dans un chemin de type: C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8.1 Tools). Pour effectuer cette comparaison, on ouvre ildasm pour chaque assembly et on affiche les metainfos en allant dans View ⇒ Metainfo ⇒ Show (il faut que dans le menu metainfo aucune entrée ne soit cochée).

En comparant les metainfos des différentes versions de QuickSort.dll, on peut indiquer:

  • Il n’y a pas de différences entre les assemblies ciblant .NET 6.0 pour Windows ou pour Linux et
  • Entre des assemblies ciblant le framework .NET historique et NET 6.0, on peut citer quelques différences:
    • La référence vers l’assembly principale spécifique à chaque framework:
      • System.Runtime pour .NET 6.0
      • mscorlib pour le framework .NET historique
    • La présence d’attributs générés par le compilateur dans l’assembly ciblant .NET:
      • System.Runtime.CompilerServices.RefSafetyRulesAttribute: permettant d’indiquer que le module a été compilé en respectant les règles de sécurité sur les ref C# 11.
      • System.Runtime.CompilerServices.CompilerGeneratedAttribute: permettant de distinguer un objet généré par le compilateur d’un objet généré par l’utilisateur.
    • La valeur de l’attribut System.Runtime.Versioning.TargetFrameworkAttribute:
      • .NETCoreApp,Version=v6.0 ou
      • .NETFramework,Version=v4.8

Ces différences peuvent se voir aussi directement en comparant le manifest entre les 2 assemblies:

Extrait du manifest de l’assembly ciblant le framework .NET historique: Extrait du manifest de l’assembly ciblant .NET 6.0: 
// Metadata version: v4.0.30319
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) 
  .ver 4:0:0:0
}
.assembly QuickSort
{
  // [...]
}
.module QuickSort.dll
// MVID: {F3745038-C191-4DBF-BEBB-3621DFC9BE88}
.imagebase 0x0000000180000000
.file alignment 0x00000200
.stackreserve 0x0000000000400000
.subsystem 0x0003     // WINDOWS_CUI
.corflags 0x00000001  //  ILONLY
// Image base: 0x06950000

// Metadata version: v4.0.30319
.assembly extern System.Runtime
{
  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) 
  .ver 7:0:0:0
}
.assembly QuickSort
{
  // [...]
}
.module QuickSort.dll
// MVID: {65CC543B-740E-4A65-A06C-529083C52F97}
.custom instance void 
  System.Runtime.CompilerServices.RefSafetyRulesAttribute::.ctor(int32) = 
  ( 01 00 0B 00 00 00 00 00 ) 
.imagebase 0x0000000180000000
.file alignment 0x00000200
.stackreserve 0x0000000000400000
.subsystem 0x0003     // WINDOWS_CUI
.corflags 0x00000001  //  ILONLY
// Image base: 0x08DF0000

Equivalences entre le framework .NET historique et .NET

Comme on a pu le voir précédemment, le fonctionnement général de .NET est similaire entre .NET et le framework .NET historique. Les différences les plus importantes sont dans l’amorce de l’exécutable, les répertoires parcourus pour charger les dépendances et les dépendances elles-mêmes. De ces 3 éléments, les dépendances vont fortement contribuer à rendre plus difficile la compatibilité entre .NET et le framework .NET historique. Il existe des solutions pour limiter les incompatibilités entre les 2 implémentations de façon à porter des implémentations d’un framework à l’autre en gardant en tête que le portage le plus utile est du framework .NET historique vers .NET. L’autre sens n’a pas forcément un intérêt mais on étudiera quand même cette possibilité.

La solution la plus triviale pour rendre du code prévu pour le framework .NET historique compatible avec .NET est d’utiliser .NET Standard. Toutefois dans les cas où on ne peut pas refactorer ou recompiler des assemblies, il existe d’autres solutions.

.NET Standard

.NET Standard est l’approche historique de Microsoft pour trouver une compatibilité entre le framework .NET historique et les nouveaux frameworks .NET Core/.NET. L’approche a été d’inclure des types et objets dans le standard, chaque framework implémente le standard. Ainsi lorsqu’on construit une application ou une assembly, on ne dépend plus d’un framework mais du standard. La construction de .NET Standard permet ensuite de garantir que si une assembly dépend du standard alors elle est compatible avec les frameworks implémentant ce standard (pour davantage de détails sur la construction de .NET Standard, voir Comprendre .NET Standard en 5 min). La 1ère version de .NET Standard est la version 1.0, elle comprend peu d’objets mais beaucoup de frameworks l’implémentent.

D’une façon générale, plus on incrémente les versions de .NET Standard et plus le standard prend en compte des types et des objets (voir le tableau sur dotnet.microsoft.com/en-us/platform/dotnet-standard#versions):

Comparaison entre .NET Standard 1.0 et .NET Standard 2.1

Ainsi:

  • Plus on incrémente les versions de .NET Standard et moins de framework implémente le standard: cela s’explique par le fait que les frameworks les plus obsolètes n’évoluent plus.
  • La dernière version du standard c’est-à-dire la 2.1 n’est pas prise en charge par le framework .NET historique. Le framework .NET 4.8.x implémente au maximum .NET Standard 2.0.

Lorsqu’on développe une application ou des assemblies, il est tentant de les faire dépendre de .NET Standard plutôt qu’un framework particulier. Il faut, toutefois, avoir en tête que l’approche .NET Standard est abandonnée et ce standard ne sera plus incrémenté(*). Ainsi la version 8.0 de .NET qui est la dernière version de ce framework ne prend en charge aucune version de .NET Standard. La dernière version de .NET implémentant .NET Standard est la version 7.0. .NET Standard convient bien pour les anciennes applications, en particulier celles utilisant le framework .NET historique car cela permet de procéder par étape si on souhaite porter ces applications sur .NET. Toutefois dans le cadre de nouvelles applications, il vaut mieux utiliser directement .NET.

En effet, actuellement la très grande majorité des fonctionnalités du framework .NET historique existe en .NET y compris les fonctionnalités spécifiques aux plateformes Windows (WPF, WinForms, C++/CLI etc…). D’autre part, lorsqu’une fonctionnalité dans le framework .NET historique n’existe pas en .NET, il existe des équivalents. Il n’y a donc plus de raisons de chercher à garder une compatibilité avec la framework .NET historique.

Exemple d’utilisation de .NET Standard

A titre d’exemple, on se propose d’utiliser .NET Standard comme framework cible pour des assemblies de type bibliothèque de classes (i.e. class library). Dans notre exemple, on considère 2 assemblies:

  • QuickSort.dll: bibliothèque de classes comportant la classe QuickSort (l’implémentation de cette classe n’a pas d’importance): 
    namespace Example
{
  public class QuickSort
  {
  // ...
  }
}
  • Launcher.exe: exécutable consommant l’assembly QuickSort.dll: 
    namespace Example.Launcher
{
  class TestClass
  {
    static void Main(string[] args)
    {
      var quickSort = new QuickSort(10);
      Console.WriteLine($"Original numbers: {string.Join("; ", quickSort.OriginalNumbers)}");
      var sortedNumbers = quickSort.Sort();
      Console.WriteLine($"Sorted numbers: {string.Join("; ", sortedNumbers)}");
    }
  }
}

Ces 2 assemblies ciblent .NET 6.0. Si on regarde la propriété TargetFramework dans les .csproj:

  • QuickSort.dll: 
    <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>net6.0</TargetFramework> 
  </PropertyGroup>
</Project>
  • Launch.exe: 
    <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\QuickSort\QuickSort.csproj" />
  </ItemGroup>
</Project>

On souhaite modifier le framework cible de QuickSort.dll pour cibler .NET Standard plutôt qu’un framework précis. Si on regarde le tableau de compatibilité sur learn.microsoft.com/en-us/dotnet/standard/net-standard, on peut voir que .NET 6.0 implémente toutes les versions de .NET Standard:

.NET 6.0 implémente toutes les versions de .NET Standard

De façon à être compatible avec le framework .NET historique, on va cibler .NET Standard 2.0 (le framework .NET historique n’implémente pas .NET Standard 2.1).

Pour changer le framework cible dans Visual Studio:

  1. Clique droit sur le projet puis Properties
  2. Dans la partie Application ⇒ General ⇒ Target Framework

    Comme on peut le voir, on ne voit pas .NET Standard. Cela s’explique par le fait que .NET Standard est abandonné et Visual Studio n’expose pas directement la possibilité de sélectionner .NET Standard. On peut toutefois le faire en faisant:

    • Un clique droit sur le projet puis Edit project file.
    • Il faut modifier le fichier .csproj en remplaçant net6.0 par netstandard2.0 pour le paramètre TargetFramework: 
      <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>netstandard2.0</TargetFramework>   
    <Nullable>disable</Nullable>
  </PropertyGroup>
</Project>

      netstandard2.0 est un moniker du framework à cibler pour .NET Standard 2.0. On peut voir d’autres exemples de monikers sur learn.microsoft.com/en-us/dotnet/standard/frameworks.

Si on compile le projet QuickSort en l’état, on peut obtenir des erreurs dues à certaines fonctionnalités n’étant pas compatibles avec certaines versions de C#, par exemple:

Feature 'global using directive' is not available in C# 7.3. Please use language version 10.0 or greater.

On peut résoudre ce problème en désactivant les fonctionnalités incompatibles en rajoutant dans le .csproj:

<ImplicitUsings>disable</ImplicitUsings>

La compilation réussit puisque Launcher.exe cible .NET 6.0 qui est compatible avec .NET Standard 2.0.
Si on change le framework cible de Launcher.exe en choisissant le framework .NET historique (moniker net48):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net48</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\QuickSort\QuickSort.csproj" />
  </ItemGroup>
</Project>

La compilation réussit toujours puisque le framework .NET 4.8 est compatible avec .NET Standard 2.0.

Construction de .NET Standard

Pour comprendre la façon dont .NET Standard est construit, voir Comprendre .NET Standard en 5 min.

Comme on peut le voir, compiler du code historique pour cibler .NET Standard nécessite de modifier les fichiers .csproj et de chercher un compromis dans le choix de la bonne version de .NET Standard. Ces étapes peuvent être couteuses en refactoring dans des projets de grande taille.

Compatibility shim

Utiliser .NET Standard n’est pas la seule façon d’utiliser des assemblies ne ciblant pas le même framework. Les compatibility shims ont régulièrement été utilisés par Microsoft pour assurer une compatibilité ascendante de ses frameworks:

  • Entre la version 2.0 et 4.0 du framework .NET historique,
  • Entre le framework .NET historique et .NET Core 2.0 avec Windows Compatibility Pack,
  • Entre le framework .NET historique 4.8 et .NET.

On va s’intéresser spécifiquement à ce dernier cas. Le but étant de pouvoir utiliser une assembly ciblant le framework .NET historique dans une application .NET sans recompilation et sans modifier le framework cible. Dans ce cas, la compatibility shim utilisée consiste à effectuer des redirections de types (i.e. Type forwarding). On va détailler cette approche par la suite.

De façon à expliciter l’approche des compatibility shims, on se propose de croiser l’utilisation d’assemblies ne ciblant pas les mêmes frameworks:

  • En consommant une assembly ciblant le framework .NET historique dans une application .NET et
  • En consommant une assembly ciblant .NET dans une application ciblant le framework .NET historique.

Utiliser des assemblies framework .NET dans une application ciblant .NET

Cette approche consiste à vérifier s’il est possible de charger une dépendance ciblant le framework .NET historique à partir d’une application .NET. Comme on a pu le voir précédemment, le fonctionnement du CLR entre le framework .NET historique et .NET est très similaire, les grandes différences résident dans les chemins utilisés pour la recherche des dépendances. D’autre part, on a pu observer qu’il n’y a pas de différences dans la structure des assemblies lorsqu’elles ciblent des frameworks différents. La différence réside essentiellement dans les dépendances requises.

C’est essentiellement ce dernier point que Microsoft a tenté de résoudre pour permettre de charger des assemblies ciblant le framework .NET historique dans une application .NET. La compatibility shim utilisée consiste à effectuer une redirection des types (i.e. Type forwarding) du framework historique vers les mêmes types sous .NET.

Si on reprend l’exemple précédent avec les assemblies Launcher.exe et QuickSort.dll . On compile l’assembly QuickSort.dll pour cibler le framework .NET historique:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>net48</TargetFramework>
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>disable</Nullable>
    <Platforms>AnyCPU;x64</Platforms>
  </PropertyGroup>
</Project>

Si on regarde le manifest de l’assembly avec ildasm.exe (accessible sur C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8.1 Tools), on peut voir:

// Metadata version: v4.0.30319
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )             
  .ver 4:0:0:0
}
.assembly QuickSort
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices
    .CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Runtime.CompilerServices
    .RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78   
                                                       63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 )     

   // ...
  .hash algorithm 0x00008004
  .ver 1:0:0:0
}

L’assembly possède une dépendance vers mscorlib.dll qui est l’assembly de base de framework .NET historique.

Ensuite on compile l’assembly Launcher.exe en mode “self-containded”:

  1. Faire un clique droit sur le projet Launcher puis cliquer sur Publish
  2. Cliquer sur Show all settings puis indiquer les paramètres:
    • Configuration: Release | Any CPU
    • Target Framework: net6.0
    • Deployment mode: Self-contained
    • Target runtime: win-x64
  3. Cliquer sur Save puis Publish

Dans le répertoire de sortie, on peut constater qu’il contient toutes les dépendances. Si on ouvre l’assembly mscorlib.dll avec ildasm, on constate dans le manifest:

// Metadata version: v4.0.30319
.assembly extern System.Private.CoreLib
{
  .publickeytoken = (7C EC 85 D7 BE A7 79 8E )             
  .ver 0:0:0:0
}
// ...
.class extern forwarder System.Object
{
  .assembly extern System.Private.CoreLib
}
// ...

L’assembly mscorlib.dll n’est pas une vraie assembly. Il n’y a pas d’implémentation concernant les objets. Ainsi, l’objet System.Object ne possède pas d’implémentation dans cette assembly. En revanche, elle contient des redirections de types. L’objet System.Object est redirigé vers l’assembly System.Private.CoreLib. Cette assembly fait partie de .NET et contient des types de base du framework.

Si on exécute l’application, on constate qu’elle s’exécute normalement. La dépendance QuickSort.dll est bien chargée malgré le fait qu’elle cible le framework .NET historique. Les redirections de type permettent de substituer les types du framework .NET historique vers les types correspondant dans le .NET.

Ainsi le gros avantage de cette approche est qu’elle ne nécessite pas de recompilation ni de changement de framework cible (comme pour l’approche .NET Standard). Il faut, toutefois, avoir en tête que cette compatibility shim n’est pas infaillible: il peut subsister des différences entre une fonction appelée dans le framework .NET historique et la fonction se trouvant dans l’assembly vers laquelle les redirections sont effectuées. La moindre différence de signature entraînera une exception à l’exécution. D’autre part, plus .NET évolue et plus il s’écarte du framework .NET historique rendant les probabilités d’incompatibilités de plus en plus importantes.

Cette approche est donc plus risquée que .NET Standard puisque les problèmes d’incompatibilités ne peuvent être constatés qu’à l’exécution et non durant la compilation. Il faut donc bien tester l’exécution du code en essayant de balayer tous les scénarios d’appels de fonction utilisant une redirection de type.

Utiliser des assemblies .NET dans une application framework .NET

Cette approche consiste à effectuer l’inverse de ce que nous avons expérimenté précédemment. Nous cherchons à exécuter une application ciblant le framework .NET historique et à charger une assembly ciblant .NET.

Ainsi de façon à ne pas avoir d’erreurs de compilation, on compile Launcher.exe et QuickSort.dll en ciblant le framework .NET historique:

  1. On modifie le fichier .csproj de Launcher.exe de cette façon: 
    <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <Platforms>AnyCPU;x64</Platforms>
    <TargetFramework>net48</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\QuickSort\QuickSort.csproj" />
  </ItemGroup>
</Project>
  2. De même pour QuickSort.dll: 
    <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <TargetFramework>net6.0</TargetFramework> 
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>disable</Nullable>
    <Platforms>AnyCPU;x64</Platforms>
  </PropertyGroup>
</Project>
  3. L’application devrait compiler normalement et le répertoire de sortie devrait contenir les fichiers:
    • Launcher.exe
    • Launcher.exe.config
    • Launcher.pdb
    • QuickSort.dll
    • QuichSort.pdb
  4. On publie QuickSort.dll pour cibler .NET en mode “self-contained” de façon à ce que le répertoire de sortie contienne toutes les dépendances .NET. On effectue un clique droit sur le projet QuickSort puis on clique sur Publish
  5. Cliquer sur Show all settings puis indiquer les paramètres:
    • Configuration: Release | Any CPU
    • Target Framework: net6.0
    • Deployment mode: Self-contained
    • Target runtime: win-x64
  6. Cliquer sur Save puis Publish

    Dans le répertoire de sortie, on peut constater qu’il contient toutes les dépendances.

  7. Copier toutes les dépendances du répertoire de sortie dans le répertoire de sortie de Launcher.exe.

Si on exécute l’application, on obtient l’erreur suivante:

Unhandled Exception: System.TypeLoadException: Could not load type 'System.Object' from assembly 'System.Private.CoreLib, Version=7.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e' because the parent does not exist.

Ceci s’explique par le chargement du type System.Object à partir de 2 emplacements différents.
Si on regarde le code IL du constructeur .ctor : void () de la classe Example.Launcher.TestClass de l’assembly Launcher.exe avec ildasm.exe:

.method public hidebysig specialname rtspecialname 
    instance void  .ctor() cil managed
{
  // Code size     7 (0x7)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  call     instance void [mscorlib]System.Object::.ctor()
  IL_0006:  ret
} // end of method TestClass::.ctor

On peut voir que le type System.Object est chargé à partir de l’assembly mscorlib.dll (appartenant au framework .NET historique).

Si on regarde le code IL du constructeur .ctor : void() de la classe Example.QuickSort de l’assembly QuickSort.dll avec ildasm.exe:

.method public hidebysig specialname rtspecialname 
    instance void  .ctor(int32 numberCount) cil managed
{
  // Code size     51 (0x33)
  .maxstack  3
  .locals init (class [System.Runtime]System.Random V_0,
       int32 V_1)
  IL_0000:  ldarg.0
  IL_0001:  call     instance void [System.Runtime]System.Object::.ctor()
  IL_0006:  ldarg.0
  // ...
} // end of method QuickSort::.ctor

On constate que le type System.Object est chargé à partir de l’assembly System.Runtime (appartenant au framework .NET).

Ainsi au démarrage de l’application, le CLR charge le type System.Object à partir de mscorlib.dll. Plus tard dans l’exécution de l’application pour le constructeur de la classe Example.QuickSort, il tente d’utiliser le type System.Object à partir de System.Runtime, or si ce type est déjà chargé toutefois il provient de 2 assemblies différentes d’où l’erreur à l’exécution.

Dans le message d’erreur "Could not load type 'System.Object' from assembly 'System.Private.CoreLib [...]' because the parent dœs not exist.", on peut se demander ce que signifie le terme “parent” ? Le code du CLR permet de comprendre ce terme: dans la fonction QuickSort.dllClassLoader::LoadApproxParentThrowing (le message de l’erreur est IDS_CLASSLOAD_PARENTNULL), on comprend que “parent” désigne le parent de tous les objets en .NET c’est-à-dire System.Object. Lors de l’exécution de ce code, le CLR part du principe que tous les objets en .NET ont pour parent System.Object dans mscorlib.dll or l’objet System.Object dans System.Private.CoreLib ne possède pas pour parent System.Object dans mscorlib.dll. La recherche du parent échoue pour System.Object dans System.Private.CoreLib d’où l’erreur.

Par suite l’objet System.Object dans System.Private.CoreLib ne peut être chargé. Ce problème ne permet pas une exécution de cette façon, ce qui rend incompatible les assemblies .NET avec les applications du framework .NET historique. Cela peut se comprendre puisque ce use-case n’a pas un réel intérêt fonctionnel (compatibilité descendante). Microsoft n’a donc pas cherché à le résoudre.

Conclusion

Pour une application, lorsque le volume de code existant est important, il est compliqué de savoir quelle est la meilleure approche pour faire évoluer les différentes dépendances et éviter une trop grande dette technique. Bien-que source d’instabilité, dans le milieu des années 2010, il aurait été inconcevable pour Microsoft de continuer à faire évoluer .NET sans proposer une réelle rupture en ouvrant cette technologie à d’autres plateformes que Windows. Problématique pour beaucoup d’équipes de développeurs, cette rupture tend à se stabiliser. En effet, actuellement Microsoft, a terminé sa migration du framework .NET historique vers .NET:

  • Le framework .NET historique n’évolue, désormais, plus fonctionnellement,
  • .NET Standard qui était l’approche de transition entre le framework .NET historique et .NET, est abandonné,
  • Le renommage de .NET Core en .NET qui était l’appellation initiale du framework .NET historique achève de tourner la page du framework historique.

Même si la période de transition entre l’arrêt du framework .NET historique et la poursuite des nouvelles fonctionnalités exclusivement sur .NET est maintenant terminée, elle aura duré 4 ans entre la 1ère version de .NET Core en juin 2016 et l’annonce de l’abandon de .NET Standard en septembre 2020. Durant 4 ans, pour tous les développeurs .NET s’est posé la douloureuse question de savoir comment faire évoluer son application:

  • Continuer à développer en ciblant le framework .NET historique en 4.8,
  • Migrer en ciblant .NET Standard,
  • Migrer en ciblant .NET Core puis .NET.

Pour encore beaucoup d’applications, la masse de code peut rendre cette évolution compliquée et couteuse. Dans ce optique, cet article avait pour but de montrer que l’approche .NET n’est pas complètement différente de l’approche du framework .NET historique:

  • Les assemblies ont la même structure entre les différents frameworks,
  • Suivant le framework ciblé, la plus grande différence dans les assemblies réside dans les dépendances,
  • Le CLR se comporte de la même façon pour charger des dépendances même si les répertoires de recherche des dépendances ne sont pas les mêmes.
  • Certaines fonctionnalités comme les AppDomains sont différentes entre le framework .NET historique et .NET.
  • Des compatibility shims permettent de continuer à utiliser des assemblies ciblant le framework .NET historique dans des applications .NET au prix d’effectuer des tests à l’exécution pour minimiser le risque d’exception en cas d’incompatibilité.
  • Ces compatibility shims permettent d’éviter de devoir recompiler ou changer la cible d’assemblies historiques.

J’espère que cet article vous aura aider à appréhender plus facilement le passage du framework .NET historique vers .NET.

Références

(*)Abandon .NET Standard:

Changement des assemblies:

App host:

AssemblyLoadContext

Affichage des dépendances

Type forwarding:

Assembly structure:

Autres:

Système d’import de modules Python


Cet article fait partie d’une série d’articles sur la syntaxe de base Python.

Le but de cet article est d’expliquer les imports de modules Python (les modules d’extension ne seront pas abordés).
Dans un premier temps, on va décrire brièvement le fonctionnement du système d’import de modules. Ensuite, on va compléter cette description avec un exemple. Enfin, on va rappeler la syntaxe pour importer un module et obtenir des informations sur un module importé.

Sommaire

Fonctionnement du système d’import
Mécanisme d’import des modules
Attributs des modules
Chemin des modules dans les packages
Encapsulation

Import d’un package
Python path
Import de modules
Avoir des informations sur un module importé

Les seuls objets Python sont les modules quelque soit leur implémentation:

  • les modules purs implémentés en Python sous la forme de fichier .py,
  • les modules d’extensions en C,
  • etc…

Les packages sont des objets Python pouvant s’apparenter à des répertoires. Ces packages contiennent des sub-packages ou des modules. Un package est un module avec un attribut __path__.


Il existe une différence entre l’identification des modules et packages Python et le chemin des fichiers ou répertoires correspondant dans le système de fichiers. Ainsi il faut considérer les modules et les packages comme étant un type d’objet plutôt que comme des fichiers ou des répertoires.

Par suite, les règles suivantes s’appliquent pour identifier des modules et packages par rapport aux fichiers correspondants:

  • Un module est identifié par le nom du fichier sans l’extension .py: si le fichier s’appelle hello_world.py alors le module s’appellera hello_world.
  • Un package est identifié de la même façon qu’un répertoire avec son nom.
  • Un sub-package est identifié à partir de ses packages parents suivant son chemin: ainsi si le sub-package est dans le répertoire numpy/polynomial alors le nom du sub-package sera numpy.polynomial.
  • Un module dans un package: par exemple si on considère un module sous la forme d’un fichier .py dans le répertoire numpy/polynomial/chebyshev.py alors l’identifiant du module sera numpy.polynomial.chebyshev.

Fonctionnement du système d’import

Un import consiste à effectuer 2 opérations:

  • La recherche d’un module nommé et
  • L’attribution d’un nom à ce module, la portée de ce nom étant local.

Mécanisme d’import des modules

L’utilisation de l’instruction import correspond à un appel à la fonction __import__() puis à l’attribution d’un nom local aux modules importés. Cette attribution se fait en rajoutant une entrée dans le dictionnaire sys.module. Ce dictionnaire permet de retrouver un module en fonction de son nom.

L’exécution de la fonction __import__() déclenche une série d’étapes qui ont pour but de trouver le module à charger:

  1. Suivant le nom du module, une recherche est effectuée pour déterminer l’emplacement du module en fonction de son nom.
  2. Avant d’effectuer une recherche à proprement parlé, une recherche est faite en utilisant le dictionnaire sys.modules contenant les modules en fonction du nom. Si le module n’est pas trouvé dans ce dictionnaire, la recherche se poursuit.
  3. La recherche est effectuée par des objets appelés finders ou des importers. D’autres objets appelés loaders permettent de charger les modules. Les importers sont à la fois des finders et des loaders.

    Par défaut, Python contient un certain nombre de finders et importers en parcourant sys.meta_path. Tous les objets de sys.meta_path sont appelés successivement pour trouver le module.

    Pour voir le contenu du tableau sys.meta_path, il suffit d’exécuter:

    >>> import sys
>>> sys.meta_path
[_frozen_importlib.BuiltinImporter,
_frozen_importlib.FrozenImporter,
_frozen_importlib_external.PathFinder,
<six._SixMetaPathImporter at 0xffff90cc1fa0>,
<pkg_resources.extern.VendorImporter at 0xffff90a7ceb0>]

    On peut voir que la recherche est effectuée sur les modules “built-in” c’est-à-dire des modules écrit en C faisant partie du shell Python. Dans un 2e temps, la recherche s’effectue pour des modules “frozen”. Les modules “frozen” sont des modules compilés en byte-code exécutables sans l’utilisation de Python. Dans 3e temps, une correspondance est cherchée entre le nom du module et son emplacement suivant le chemin d’import (i.e. import path). La liste des emplacements du chemin d’import peut être listée en affichant le contenu de sys.path (les chemins dépendent de la distribution Python, de l’environnement et du contexte d’exécution). 2 autres variables peuvent être utilisées pour trouver le chemin d’un module sys.path_hooks et sys.path_importer_cache.

    L’emplacement d’un module n’est pas forcément sur le disque, il pourrait être dans une archive .zip ou accessible avec une URL.

    Lorsqu’un finder trouve la correspondance entre un module et son nom, il retourne le loader correspondant. Si le finder est un importer, il retourne sa propre instance.

  4. Le module est rajouté dans sys.modules avant son exécution. Si l’exécution du module échoue, il est retiré du dictionnaire sys.modules. L’ajout dans sys.modules est faite au préalable car l’exécution du module peut l’amener à se charger lui-même ce qui pourrait provoquer une boucle récursive infinie en le rajoutant indéfiniment dans sys.modules.
  5. Le loader correspondant exécute le module (en appelant la méthode exec_module()). Les modules peuvent se trouver dans des packages. Un package est lui-même un module avec un attribut __path__ indiquant le chemin du package.

    Il existe 2 types de packages:

    • Regular packages: ils sont implémentés dans un répertoire contenant un fichier __init__.py. Ce fichier est exécuté implicitement à chaque import de ce type de packages. Les sub-packages c’est-à-dire les répertoires enfant doivent aussi contenir des fichiers __init__.py qui, en cas d’import, seront exécutés après le __init__.py du répertoire parent.
    • Namespace packages: ces packages sont constitués de portions pouvant se trouver à des emplacements différents dans le système de fichier. Par exemple, une portion peut être un fichier sur le disque et un autre peut être à un emplacement sur le réseau.

Attributs des modules

Lors de l’import de modules, des objets correspondant sont créés pour accéder aux fonctions dans les modules. Le mécanisme d’import ajoute quelques attributs indiquant d’où provient le module:

  • __name__: le nom du module
  • __loader__: nom du loader utilisé pour importer le module. Les finders et loaders disponibles peuvent être listés avec sys.meta_path.
  • __package__: dans le cas d’un package cet attribut possède la même valeur que __name__.
  • __spec__: ensemble des spécifications utilisées pour le système d’import.
  • __path__: chemin du package sur le disque. Ce chemin dépend de l’environnement virtuel utilisé.
  • __file__: fichier __init__.py utilisé itinialement. Ce chemin dépend de l’environnement virtuel utilisé.
  • __cached__: fichier compilé (voir CPython) utilisé à l’exécution. Ce chemin dépend de l’environnement virtuel utilisé.

En utilisant la fonction dir(), on peut voir la liste des attributs d’un module.

Chemin des modules dans les packages

Dans les packages, les imports de modules se font avec un chemin relatif au module courant ou en indiquant le chemin à partir du répertoire parent. Comme indiqué précédemment, les modules sont identifiés par nom. Dans le cas de modules présents sur le disque, le nom permet d’indiquer l’emplacement physique du fichier .py correspondant. Le nom des modules à importer doit respecter les règles suivantes:

  • Le nom ne doit pas comporter de / ou \ (à la différence d’un chemin de fichier), ils doivent être remplacés par ..
  • . permet d’indiquer le répertoire courant.
  • .. permet d’indiquer le répertoire parent.
  • Le nom du module correspond au nom du fichier correspondant sans l’extension .py.

Ainsi si on veut indiquer le chemin de:

  • ./Module1.py alors l’import peut se faire avec from .Module1 import *
  • ./InnerModule/Module3.py alors l’import peut se faire avec from .InnerModule.Module3 import *
  • ../Module2.py l’import peut se faire avec from ..Module2 import *

Par exemple si on considère les fichiers suivants:

Hello
├── InnerModule
│ ├── __init__.py
│ └── Module3.py
├── __init__.py
├── Module1.py
├── Module2.py
└── setup.py

Le contenu des fichiers est:

  • Hello/Module1.py: 
    from Hello.Module2 import HelloFromModule2

def HelloFromModule1():
    print("Hello from module 1")
    HelloFromModule2()
  • Hello/Module2.py: 
    from Hello.InnerModule.Module3 import HelloFromModule3

def HelloFromModule2():
    print("Hello from module 2")
    HelloFromModule3()
  • Hello/InnerModule/Module3.py: 
    def HelloFromModule3():
    print("Hello from module 3")

Dans ces exemples, les imports ont été faits suivant le répertoire parent du package. Si on avait indiqué les chemins de façon relative, il aurait fallu effectuer les imports de cette façon:

  • Hello/Module1.py: 
    from .Module2 import HelloFromModule2
  • Hello/Module2.py: 
    from .InnerModule.Module3 import HelloFromModule3
Code source et exécution

On peut voir les fichiers de cet exemple dans le repository GitHub: github.com/msoft/python_example_module_import.

Il est préférable de créer un environnement virtuel avant de continuer. Pour créer un environnement virtuel, on peut exécuter:

~/python_example_module_import% python -m venv venv
~/python_example_module_import% source venv/bin/activate

On peut ensuite installer les packages nécessaires pour construire le package:

(venv) ~/python_example_module_import/package_creation% pip install setuptools wheel

Pour construire le package .whl, il faut exécuter dans le répertoire package_creation:

(venv) ~/python_example_module_import/package_creation% python setup.py bdist_wheel

Le package sera créé dans le répertoire: python_example_module_import/package_creation/dist.

Pour installer le package, il suffit d’exécuter:

(venv) ~/python_example_module_import/package_creation/dist% pip install Hello-1.0-py3-none-any.whl

Les fichiers du package se trouvent dans un répertoire du type: python_example_module_import/venv/lib/python3.9/site-packages/Hello.

Enfin pour utiliser le package installé, on peut exécuter le fichier python_example_module_import/package_usage/test.py:

(venv) ~/python_example_module_import/package_usage% python test.py
Hello from module 1
Hello from module 2
Hello from module 3

Comment créer un package .whl ?

Pour créer un package, on peut utiliser un fichier setup.py et le package setuptools, voir Construire un package wheel.

Encapsulation

L’encapsulation au niveau de la syntaxe du langage à proprement parlé n’existe pas en Python. Toutefois il est possible de ne pas exposer des modules lorsqu’ils sont dans des packages. En effet dans les fichiers __init__.py des répertoires du packages, on peut indiquer les modules à importer lorsque le package est importé. Ainsi suivant les imports qui y sont effectués, on peut choisir d’exposer des modules particuliers ou de ne pas en exposer d’autres à l’extérieur.

Par exemple, si on considère l’exemple précédent, dans le fichier Hello/__init__.py, si on ne souhaite exposer que le Module1 alors on peut effectuer l’import de cette façon:

from .Module1 import HelloFromModule1

Dans ce cas à l’extérieur du package, on pourra effectuer l’import de cette façon:

import Hello as h
h.HelloFromModule1()

Le module Module2 n’étant pas exposé dans le fichier Hello/__init__.py, il n’est pas accessible de l’extérieur:

h.HelloFromModule2() # ERREUR

Pour que HelloFromModule2() soit accessible, il faut l’importer en modifiant Hello/__init__.py de cette façon:

from .Module1 import HelloFromModule1
from .Module2 import HelloFromModule2

Import d’un package

Comme indiqué précédemment:

  • Les seuls objets Python sont les modules.
  • Les packages sont des modules avec un attribut __path__.

Le système d’import a donc le même comportement qu’ils s’agissent de modules ou de packages. Il faut toutefois faire attention à la syntaxe utilisée lors de l’import. Ainsi les imports peuvent se faire:

  • Relativement au fichier courant ou
  • Par rapport au répertoire initial du package.

La recherche d’un module se fait en utilisant son nom (cf. Mécanisme d’import des modules). Le système d’import parcourt les répertoires du Python path pour trouver le module suivant son nom. Dans un premier temps, on va montrer comment récupérer les répertoires du Python path. Dans un 2e temps, on va indiquer la syntaxe d’import des modules et packages.

Python path

Le Python path est un tableau indiquant les chemins parcourus par le système d’import pour trouver un module suivant son nom. Pour obtenir cette liste de répertoire, il faut exécuter:

>>> import sys
>>> sys.path

Le résultat dépend du système d’exploitation et de la distribution Python utilisé toutefois le tableau devrait contenir en particulier:

  • Le répertoire courant,
  • Le répertoire de l’exécutable python: par exemple <répertoire d'Anaconda/lib/python3.9.
  • Le répertoire des packages: par exemple <répertoire d'Anaconda/lib/python3.9/site-packages.
  • Le répertoire des packages dans le cas d’un environnement virtuel: par exemple <répertoire env. virtuel/lib/python3.9/site-packages.

On peut voir les modules déjà importés en exécutant:

>>> sys.modules

Import de modules

Un module possède un namespace privé et ce namespace n’est pas directement accessible à l’extérieur du module. Un module peut importer un autre module.

Plusieurs syntaxes sont possibles pour importer un module:

  • import <nom du module>: le module est importé dans le namespace local toutefois tous les noms des objets ne sont pas accessibles à partir du namespace local. Pour accéder aux objets du module, il faut taper <nom du module>.<nom de l'objet>.

    Par exemple:

    import pandas
data = pandas.DataFrame()
  • import <nom de l'objet> as <nom alias>: permet d’éviter d’utiliser le nom entier du module pour accéder à ses objets. Avec cette syntaxe, le module est importé dans le namespace local toutefois les objets ne sont accessibles qu’en utilisant l’alias du module: <nom alias>.<nom de l'objet>.

    Par exemple:

    import pandas as pd
data = pd.DataFrame()
  • from <nom du module> import <nom de l'objet>: on ne charge qu’un seul objet du module dans le namespace local. Cet objet est accessible en utilisant directement son nom.

    Par exemple:

    from pandas import DataFrame
data = DataFrame()
  • from <nom du module> import *: tous les noms des objets du module sont importés dans le namespace local. Il n’est pas recommandé d’utiliser cette syntaxe car il peut y avoir des collisions entre des modules qui utiliseraient les mêmes noms d’objet. Avec cette syntaxe, les objets sont accessibles directement par leur nom.

    Par exemple:

    from pandas import *
data = DataFrame()
  • from <nom du module> import <nom de l'objet> alias <alias de l'objet>: cette syntaxe permet d’importer le nom d’un objet du module et de permettre d’utiliser cet objet en utilisant un alias.

    Par exemple:

    from pandas import DataFrame as PandasDataframe
data = PandasDataframe()

Avoir des informations sur un module importé

La fonction dir() permet de lister les noms d’objets définis dans le namespace local. Cette fonction permet de lister les variables, les fonctions et les modules.

Ainsi:

  • dir(): sans argument affiche les noms de variables, fonctions et modules qui sont accessibles dans le namespace local.
  • dir(<nom du module>): liste les objets accessibles dans le module.

Par exemple, si on importe le package numpy:

>>> import numpy as np
>>> dir(np)
['ALLOW_THREADS',
'AxisError',
'BUFSIZE',
'Bytes0',
'CLIP',
'ComplexWarning',
'DataSource',
'Datetime64',
'ERR_CALL',
'ERR_DEFAULT',
'ERR_IGNORE',
'ERR_LOG',
'ERR_PRINT',
'ERR_RAISE',
'ERR_WARN',
'FLOATING_POINT_SUPPORT',
'FPE_DIVIDEBYZERO',
'FPE_INVALID',
'FPE_OVERFLOW',
'FPE_UNDERFLOW',
...,
'True_',
'UFUNC_BUFSIZE_DEFAULT',
'UFUNC_PYVALS_NAME',
'Uint64',
'VisibleDeprecationWarning',
'WRAP',
'_NoValue',
'_UFUNC_API',
'__NUMPY_SETUP__',
'__all__',
'__builtins__',
'__cached__',
'__config__',
'__deprecated_attrs__',
'__dir__',
'__doc__',
'__expired_functions__',
'__file__',
'__getattr__',
'__git_revision__',
'__loader__',
'__name__',
'__package__',
'__path__',
'__spec__',
'__version__',
'_add_newdoc_ufunc',
'_distributor_init',
'_financial_names',
'_globals',
'_mat',
'_pytesttester',
'abs',
...,
'fft',
'square',
...,
'uint',
'uint0',
'uint16',
'uint32',
'uint64',
'uint8',
...,
'where',
'who',
'zeros',
'zeros_like']

Ainsi parmi les objets listés, il peut y avoir:

  • Des constantes: 
    >>> print(np.ERR_LOG)
5
  • Des fonctions: 
    >>> print(np.sum)
<function sum at 0xffff8c103160>
  • Des modules: 
    >>> print(np.fft)
<module 'numpy.fft' from ‘<chemin environnement virtuel>/site-packages/numpy/fft/__init__.py'>
  • Des attributs: 
    >>> print(np.__package__)
numpy
  • Des classes: 
    >>> print(np.uint)
<class 'numpy.uint64'>
Références

Dataframes Pandas

Cet article fait partie d’une série d’articles sur la syntaxe de base Python.

Un dataframe pandas est une structure de données mutable que l’on peut considérer comme un dictionnaire de séries pandas. Les colonnes sont accessibles en utilisant le nom de la colonne en tant que clé du dictionnaire. La valeur extraite avec la clé est une série qui peut avoir un index personnalisé ou non. Les valeurs d’un dataframe peuvent être de type différent toutefois il est possible d’avoir un type par colonne.

Sommaire

Initialisation
A partir d’une liste
A partir d’une liste de listes
A partir d’un dictionnaire de listes
A partir d’une liste de dictionnaires
A partir d’un dictionnaire de séries pandas
A partir d’objets de types différents
Indiquer explicitement des index (argument index)
Indiquer explicitement les colonnes (argument columns)
Indiquer explicitement le type des valeurs (argument dtype)
Initialiser sans effectuer de copies (argument copy)

Lire le contenu d’un dataframe
Accéder à une valeur à partir de l’index
  loc[] et iloc[]
Sous-ensembles
at[] et iat[]

Multi-index
Accès aux éléments en utilisant un multi-index
Utilisation de multi-index pour les lignes
Création de multi-index à partir d’un tableau
Création de multi-index à partir de tuples
Création de multi-index en effectuant un produit cartésien
Création de multi-index à partir d’un dataframe
Création de multi-index avec les arguments levels et codes
Nommer les niveaux du multi-index

Modifier un dataframe
Modifier les colonnes ou lignes
  Renommer des lignes ou colonnes
  Ajouter une colonne
  Changer l’ordre des colonnes
  Supprimer des colonnes
  Supprimer des lignes
Modification de valeurs d’un dataframe
  Modifier les valeurs d’un dataframe par condition
  Modifier un dataframe en appliquant des fonctions

Agrégation
Avec <dataframe>.groupby()
Fonction d’agrégation aggregate() ou agg()

Fonctions mathématiques
Opérations sur les dataframes
Opérations entre un dataframe et un autre type d’objet
  Argument fill_value
Opérations avec des index ou des colonnes non communs

Jointures

Concaténation

Le but de cet article est de présenter les fonctionnalités de base des dataframes pandas.

On peut importer pandas de cette façon pour utiliser les objets dans la bibliothèque:

import pandas as pd

Initialisation

On peut créer un dataframe à partir d’une liste, d’un dictionnaire de listes, d’une liste de dictionnaires ou d’un dictionnaire de séries pandas.

A partir d’une liste

A partir d’une liste, le dataframe ne contient qu’une seule colonne correspondant aux éléments de la liste. Les lignes possèdent un index par défaut non personnalisé, par exemple:

>>> data = [1, 3, 5, 7, 9, 11]
>>> df = pd.DataFrame(data)
>>> print(df)
    0
0   1
1   3
2   5
3   7
4   9
5  11

Avec cet exemple, le dataframe ne contient qu’une seule colonne '0'. Les index des lignes sont les index par défaut. Sans précision, le type est déterminé en fonction du type des valeurs de la liste:

>>> df.dtypes
0    int64
dtype: object

A partir d’une liste de listes

A partir d’une liste de listes, le dataframe contiendra les listes disposées en colonne. Les lignes possèdent un index par défaut non personnalisé.

Par exemple:

>>> data = [[1, 3, 5], ['1', '3', '5'], [1.0, 3.0, 5.0]]
>>> df = pd.DataFrame(data)
>>> print(df)
     0    1    2
0    1    3    5
1    1    3    5
2  1.0  3.0  5.0

Dans cet exemple, les types des objets sont différents pour une même colonne donnée. Ainsi si on regarde le type des objets, ils seront de type object (qui correspond au type le plus large entre les int64 et les float64):

>>> df.dtypes
     0    object
     1    object
     2    object
     dtype: object

A partir d’un dictionnaire de listes

A partir d’un dictionnaire de listes:

  • Les clés du dictionnaire correspondent aux colonnes du dataframe et
  • Les listes seront les colonnes du dataframe.

Par exemple:

>>> data = {'a': [1, 3, 5, 7, 9, 11], 'b': ['1', '3', '5', '7', '9', '11'], 'c': [1.0, 3.0, 5.0, 7.0, 9.0, 11.0]}
>>> df = pd.DataFrame(data)
>>> print(df)
    a   b     c
0   1   1   1.0
1   3   3   3.0
2   5   5   5.0
3   7   7   7.0
4   9   9   9.0
5  11  11  11.0

Le type des colonnes est déduit du type des éléments dans les listes:

>>> df.dtypes
a      int64
b     object
c    float64
dtype: object

A partir d’une liste de dictionnaires

Dans le cas d’une liste de dictionnaires:

  • Les clés des éléments dans les dictionnaires correspondent aux colonnes du dataframe,
  • Les valeurs des éléments dans les dictionnaires correspondent aux lignes du dataframe.

Par exemple:

>>> data = [{'a': 1, 'b': '1', 'c': 1.0}, {'a': 3, 'b': '3', 'c': 3.0}, {'a': 5, 'b': '5', 'c': 5.0},
       {'a': 7, 'b': '7', 'c': 7.0}, {'a': 9, 'b': '9', 'c': 9.0}]
>>> df = pd.DataFrame(data)
>>> print(df)
   a  b    c
0  1  1  1.0
1  3  3  3.0
2  5  5  5.0
3  7  7  7.0
4  9  9  9.0

Le type des colonnes est déduit du type des éléments dans les dictionnaires:

>>> df.dtypes
a      int64
b     object
c    float64
dtype: object

Dans le cas où tous les dictionnaires ne contiennent pas toutes les clés, les valeurs manquantes sont remplacées par NaN.

Par exemple, si on considère la liste de dictionnaires suivantes:

>>> data = [{'a': 1, 'b': '1', 'c': 1.0}, {'a': 3}, {'b': '5'}, {'c': 7.0}]
>>> df = pd.DataFrame(data)
     a    b    c
0  1.0    1  1.0
1  3.0  NaN  NaN
2  NaN    5  NaN
3  NaN  NaN  7.0

A partir d’un dictionnaire de séries pandas

Si on crée un dataframe à partir d’un dictionnaire de séries, chaque série correspond à une colonne du dataframe.

Par exemple:

>>> data1 = pd.Series([1, 3, 5, 7, 9])
>>> data2 = pd.Series(['1', '3', '5', '7', '9'])
>>> data3 = pd.Series([1.0, 3.0, 5.0, 7.0, 9.0])
>>> df = pd.DataFrame({'a': data1, 'b': data2, 'c': data3 })
>>> print(df)
   a  b    c
0  1  1  1.0
1  3  3  3.0
2  5  5  5.0
3  7  7  7.0
4  9  9  9.0

Le type des colonnes est déduit du type des éléments dans les séries:

>>> df.dtypes
a      int64
b     object
c    float64
dtype: object

A partir d’objets de types différents

On peut effectuer l’initialisation du dataframe avec des objets de type différent. Par exemple, si on considère une liste et une série:

>>> data = {'a': [1, 3, 5], 'b': pd.Series(['1', '3', '5'])}
>>> df = pd.DataFrame(data)
   a  b
0  1  1
1  3  3
2  5  5

Indiquer explicitement des index (argument index)

On utilise le terme “index” pour désigner les labels utilisés pour identifier les lignes en opposition aux labels utilisés pour les colonnes. Par défaut, les index des éléments sont des entiers à partir de 0. Avec l’argument index, on peut explicitement préciser des index, par exemple:

>>> data = {'a': [1, 3, 5], 'b': ['1', '3', '5'], 'c': [1.0, 3.0, 5.0]}
>>> i = ['one', 'two', 'three']
>>> df = pd.DataFrame(data, i)
       a  b    c
one    1  1  1.0
two    3  3  3.0
three  5  5  5.0

On peut aussi indiquer l’index de cette façon à l’initialisation:

>>> df = pd.DataFrame(data, index=i)

Si la taille de l’index ne correspond pas au nombre de lignes du dataframe, une erreur survient:

>>> data = {'a': [1, 3, 5], 'b': ['1', '3', '5'], 'c': [1.0, 3.0, 5.0]}
>>> i = ['one', 'two', 'three', 'four']
ValueError: Length mismatch: Expected axis has 3 elements, new values have 4 elements

On peut affecter un index particulier après initialisation avec la propriété <dataframe>.index. Il faut que la taille du tableau de l’index soit la même que le nombre de lignes du dataframe.

Par exemple:

>>> data = {'a': [1, 3, 5], 'b': ['1', '3', '5'], 'c': [1.0, 3.0, 5.0]}
>>> df = pd.DataFrame(data)
>>> print(df)
   a  b    c
0  1  1  1.0
1  3  3  3.0
2  5  5  5.0

>>> df.index = i
>>> print(df)
       a  b    c
one    1  1  1.0
two    3  3  3.0
three  5  5  5.0

On peut nommer l’index d’un dataframe avec:

<dataframe>.index.name = <chaine de caractères>

Par exemple:

>>> print(df)
   a  b    c
0  1  1  1.0
1  3  3  3.0
2  5  5  5.0
>>> df.index.name = 'Index name'
>>> print(df)
            a  b    c
Index name           
0           1  1  1.0
1           3  3  3.0
2           5  5  5.0

Indiquer explicitement les colonnes (argument columns)

On peut indiquer les colonnes du dataframe avec l’argument columns. Les noms de colonnes doivent être indiqués sous la forme d’une liste de même taille que le nombre de colonnes:

>>> data = [[1, 3, 5], ['1', '3', '5'], [1.0, 3.0, 5.0]]
>>> c = ['a', 'b', 'c']
>>> df = pd.DataFrame(data, columns=c)
>>> print(df)
     a    b    c
0    1    3    5
1    1    3    5
2  1.0  3.0  5.0

Si le tableau fourni pour le nom des colonnes n’est pas de la même taille que le nombre de colonnes du dataframe, une erreur se produit:

>>> data = [[1, 3, 5], ['1', '3', '5'], [1.0, 3.0, 5.0]]
>>> c = ['a', 'b', 'c', 'd']
>>> df = pd.DataFrame(data, columns=c)
ValueError: 4 columns passed, passed data had 3 columns

On peut affecter la propriété <dataframe>.columns après initialisation pour préciser les noms de colonnes:

>>> data = [[1, 3, 5], ['1', '3', '5'], [1.0, 3.0, 5.0]]
>>> df = pd.DataFrame(data)
>>> print(df)
     0    1    2
0    1    3    5
1    1    3    5
2  1.0  3.0  5.0
>>> c = ['a', 'b', 'c']
>>> df.columns = c
     a    b    c
0    1    3    5
1    1    3    5
2  1.0  3.0  5.0

On peut nommer les colonnes d’un dataframe avec:

<dataframe>.columns.name = <chaîne de caractères>

Par exemple:

>>> print(df)
   a  b    c
0  1  1  1.0
1  3  3  3.0
2  5  5  5.0
>>> df.columns.name = 'Column name'
>>> print(df)
Columns name  a  b    c
0             1  1  1.0
1             3  3  3.0
2             5  5  5.0

Indiquer explicitement le type des valeurs (argument dtype)

Pandas reconnait les types numpy donc on peut utiliser la même syntaxe que pour numpy pour indiquer explicitement un type à l’initialisation, par exemple:

>>> data = {'a': [1, 3, 5], 'b': ['1', '3', '5'], 'c': [1.0, 3.0, 5.0]}
>>> df = pd.DataFrame(data, dtype='f8')     # f8 pour flottant sur 8 octets/64 bits
>>> print(df)
     a    b    c
0  1.0  1.0  1.0
1  3.0  3.0  3.0
2  5.0  5.0  5.0
>>> df.dtypes
a    float64
b    float64
c    float64
dtype: object

Tous les éléments sont convertis en flottants si c’est possible.

Initialiser sans effectuer de copies (argument copy)

Par défaut, quand un dataframe pandas est initialisé à partir d’une série pandas, une copie des éléments est effectuée. Il est possible d’effectuer une initialisation du dataframe en utilisant des références vers les objets de la structure d’origine avec l’argument copy (par défaut, la valeur est copy est True):

>>> data = {'a': pd.Series([1, 2, 3, 5])}
>>> df = pd.DataFrame(data, copy=False)
>>> print(df)
   a
0  1
1  2
2  3
3  5

>>> print(data)
{'a': 0    1
1    2
2    3
3    5
dtype: int64}

>>> df['a'][1] = 1000
>>> print(data)
{'a': 0       1
1    1000
2       3
3       5
dtype: int64}

L’initialisation du dataframe étant faite avec des références, si on modifie une valeur dans le dataframe alors les éléments dans la structure d’origine sont aussi modifiés.

Lire le contenu d’un dataframe

Les attributs et fonctions suivantes permettent d’obtenir des informations sur le dataframe:

  • <dataframe>.dtypes: renvoie une série contenant les types des éléments. L’index de la série correspond aux noms de colonnes du dataframe.
  • <dataframe>.head(): renvoie un dataframe contenant les 5 premières lignes du dataframe. <dataframe>.head(8) renvoie les 8 premières lignes.
  • <dataframe>.tail(): renvoie un dataframe contenant les 5 dernières lignes du dataframe. <dataframe>.tail(8) renvoie les 8 dernières lignes.
  • <dataframe>.info(): retourne des informations concernant le dataframe (noms, types des colonnes; nombre des valeurs non-nulles; mémoire occupée par l’instance du dataframe), par exemple: 
    >>> data = {'a': [1, 3, 5], 'b': ['1', '3', '5'], 'c': [1.0, 3.0, 5.0]}
>>> df = pd.DataFrame(data)
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   a       3 non-null      int64  
 1   b       3 non-null      object 
 2   c       3 non-null      float64
dtypes: float64(1), int64(1), object(1)
memory usage: 200.0+ bytes
  • <dataframe>.columns: renvoie un objet itérable permettant d’obtenir le nom des colonnes. <dataframe>.columns.values renvoie les noms de colonnes sous la forme d’un tableau numpy.
  • <dataframe>.index: renvoie un objet itérable permettant d’obtenir les index (nom de lignes). <dataframe>.index.values renvoie les noms des index sous la forme d’un tableau numpy.
  • <dataframe>.values: retourne l’ensemble des éléments du dataframe sous la forme d’un tableau numpy.
  • <dataframe>.describe(): renvoie des informations statistiques sur les éléments du dataframe quand les éléments sont des valeurs numériques.

    Par exemple:

    >>> data = {'a': [1, 3, 5], 'b': ['1', '3', '5'], 'c': [1.0, 3.0, 5.0]}
>>> df = pd.DataFrame(data)
>>> df.describe()
         a    c
count  3.0  3.0
mean   3.0  3.0
std    2.0  2.0
min    1.0  1.0
25%    2.0  2.0
50%    3.0  3.0
75%    4.0  4.0
max    5.0  5.0
  • <dataframe>.shape renvoie la taille du dataframe sous la forme d’un tuple.
  • len(<dataframe>) ou len(<dataframe>.index) renvoie le nombre de lignes du dataframe.
  • len(<dataframe>.columns) renvoie le nombre de colonnes du dataframe.
  • <dataframe>.memory_usage(): retourne la taille occupée pour chaque colonne.

Accéder à une valeur à partir de l’index

Comme indiqué auparavant, un dataframe pandas peut être considéré comme un dictionnaire de séries pandas. On peut accéder à chaque série en utilisant les index des colonnes, par exemple si on considère le dataframe:

>>> data = {'a': ['a0', 'a1', 'a2'], 'b': ['b0', 'b1', 'b2'], 'c': ['c0', 'c1', 'c2']}
>>> i = ['l0', 'l1', 'l2']
>>> df = pd.DataFrame(data, index=i)
>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

Alors df['a'] est une série contenant tous les éléments de la colonne 'a':

>>> df['a']
l0    a0
l1    a1
l2    a2
Name: a, dtype: object

On peut accéder directement à un élément en utilisant l’index de la série:

>>> df['a']['l1']
'a1'

loc[] et iloc[]

La fonction loc[] permet d’accéder à un ou plusieurs éléments en utilisant des index sous la forme <index ligne>, <index colonne>, par exemple:

>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

>>> df.loc['l1', 'b']
'b1'

Dans cet exemple, il existe 2 index:

  • L’index personnalisé paramétré à l’initialisation du dataframe:
    • Lignes: list(df.index) ⇒ ['l0', 'l1', 'l2']
    • Colonnes: list(df.columns) ⇒ ['a', 'b', 'c']
  • L’index implicite du dataframe sous la forme numérique.

On peut utiliser loc[] pour les index personnalisés et iloc[] pour les index numériques. S’il n’existe pas d’index personnalisé alors loc[] fonctionne avec des index implicites numériques.

Par exemple:

>>> data1 = {'a': ['a0', 'a1', 'a2'], 'b': ['b0', 'b1', 'b2'], 'c': ['c0', 'c1', 'c2']}
>>> i = ['l0', 'l1', 'l2']
>>> df_custom_indexes = pd.DataFrame(data1, index=i)
>>> print(df_custom_indexes)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

>>> data2 = [['a0', 'b0', 'c0'], ['a1', 'b1', 'c1'], ['a2', 'b2', 'c2']]
>>> df_implicit_indexes = pd.DataFrame(data2)
>>> print(df_implicit_indexes)
    0   1   2
0  a0  b0  c0
1  a1  b1  c1
2  a2  b2  c2

Dans le cas des index numériques implicites loc[<index ligne>, <index colonne>] fonctionne:

>>> df_implicit_indexes.loc[1, 2]
'c1'

Si des index personnalisés existent, loc[] ne fonctionne pas avec les index numériques:

>>> df_custom_indexes[1, 2]
KeyError: (1, 2)

>>> df_custom_indexes.loc['l1', 'c']
'c1'

iloc[<index ligne>, <index colonne>] fonctionne dans tous les cas seulement pour des index numériques:

>>> df_implicit_indexes.iloc[1, 2]
'c1'

>>> df_custom_indexes.iloc[1, 2]
'c1'

Sous-ensembles

On peut extraire des sous-ensembles en utilisant des index sous la forme slicing:

[<index de début>:<index de fin exclu>:<pas utilisé>]

Ainsi comme pour les listes python classiques:

  • [2:] permet de commencer à l’index 2 (3e élément) jusqu’au dernier.
  • [:3] permet de commencer du début jusqu’à l’index 2 (3e élément). L’index (4e élément) est exclu.
  • [:] désigne tous les éléments de la liste.

Par exemple, si on considère le dataframe définit plus haut:

>>> print(df_implicit_indexes)
    0   1   2
0  a0  b0  c0
1  a1  b1  c1
2  a2  b2  c2

Alors:

  • df_implicit_indexes.iloc[1, 2] correspond à l’élément à l’index ligne 1 (2e ligne) et colonne 2 (3e colonne): 
    'c1'
  • df_implicit_indexes.iloc[:, 2] correspond à une série contenant toutes les lignes et la colonne 2 (3e colonne): 
    0    c0
1    c1
2    c2
Name: 2, dtype: object
  • df_implicit_indexes.iloc[:, 0:2] correspond à un dataframe contenant toutes les lignes et les colonnes 0 à 2, la colonne 2 étant exclue: 
        0   1
0  a0  b0
1  a1  b1
2  a2  b2
  • df_implicit_indexes.iloc[:, 0:2:2] correspond à un dataframe contenant toutes les lignes et les colonnes 0 à 2 avec la colonne 2 exclue. Les colonnes seront énumérées par pas de 2: 
        0
0  a0
1  a1
2  a2
  • df_implicit_indexes.iloc[0:2, 2] correspond à une série contenant les lignes 0 à 2 avec 2 exclu et la colonne 2 (3e colonne): 
    0    c0
1    c1
Name: 2, dtype: object
  • df_implicit_indexes.iloc[1, [0, 2]] correspond à une série contenant la ligne 1 (2e ligne) et les colonnes 0 (1ère colonne) et 2 (3e colonne): 
    0    a1
2    c1
Name: 1, dtype: object

Avec loc[] et des index personnalisés, on peut aussi utiliser la forme slicing [:] ou [<index 1>, <index 2>, ..., <index i>], par exemple:

  • df_custom_indexes.loc[:,'c'] correspond à une série contenant toutes les lignes et la colonne 'c': 
    l0    c0
l1    c1
l2    c2
Name: c, dtype: object
  • df_custom_indexes.loc[['l0', 'l1'],:] correspond à un dataframe contenant les lignes 'l0' et 'l1' et toutes les colonnes: 
         a   b   c
l0  a0  b0  c0
l1  a1  b1  c1

at[] et iat[]

at[] et iat[] permettent d’extraire des éléments d’un dataframe comme les colonnes respectivement loc[] et iloc[] c’est-à-dire on peut utiliser:

  • at[] pour les index personnalisés et
  • iat[] pour les index numériques. S’il n’existe pas d’index personnalisé alors at[] fonctionne avec des index implicites numériques.

La différence est qu’avec at[] et iat[], il n’est possible d’utiliser que des index simples sans les formes slicing [:] ou [<index 1>, <index 2>, ..., <index i>]. Si on prend les exemples de dataframes définis plus haut:

>>> print(df_implicit_indexes)
    0   1   2
0  a0  b0  c0
1  a1  b1  c1
2  a2  b2  c2

Alors:

  • df_implicit_indexes.iat[1, 2] renvoie l’élément se trouvant à la ligne 1 (2e ligne) et la colonne 2 (3e colonne): 
    'c1'
  • df_implicit_indexes.iat[:, 2] renvoie une erreur: 
    ValueError: iAt based indexing can only have integer indexers
  • df_implicit_indexes.iat[:, [0, 2]] renvoie une erreur: 
    ValueError: iAt based indexing can only have integer indexers

>>> print(df_custom_indexes)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

Alors:

  • df_custom_indexes.at['l1', 'c'] renvoie l’élément à la ligne l1 et la colonne c: 
    'c1'
  • df_custom_indexes.at[1, '2] renvoie une erreur car il existe des index personnalisés pour df_custom_indexes.
  • df_implicit_indexes.at[1, 2] ne renvoie pas d’erreur car il n’existe que des index numériques pour df_implicit_indexes: 
    'c1'

Multi-index

Les multi-index permettent d’avoir des index et des index de colonnes sur plusieurs niveaux de façon à identifier des valeurs suivant un ensemble de clés. Pour accéder aux éléments du dataframe, au lieu d’utiliser un index à une valeur, on peut utiliser un agrégat de valeurs. Les multi-index peuvent être utilisés pour identifier des colonnes ou des lignes du dataframe. Plus précisemment, le terme “index” est utilisé pour désigner des labels pour les lignes toutefois le terme “multi-index” est applicable pour les lignes et les colonnes.

Par exemple, si on considère le dataframe suivant:

>>> data = [['a0', 'a1', 'a2', 'a3'], ['b0', 'b1', 'b2', 'b3'], ['c0', 'c1', 'c2', 'c3'], ['d0', 'd1', 'd2', 'd3']]
>>> df = pd.DataFrame(data)
>>> print(df)
    0   1   2   3
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

On utilise un index implicite pour les colonnes et les lignes:

>>> list(df.index)
[0, 1, 2, 3]

>>> list(df.columns)
[0, 1, 2, 3]

Si on utilise un index explicite pour les colonnes:

>>> df_index = ['a', 'b', 'c', 'd']
>>> df.columns = df_index
>>> print(df)
    a   b   c   d
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

On peut identifier les colonnes en utilisant une valeur parmi les valeurs de l’index explicite:

>>> df.loc[1, 'b']
'b1'

Si on considère le multi-index suivant à 2 niveaux:

>>> df_index_values = [['group1', 'group1', 'group2', 'group2'], ['a', 'b', 'c', 'd']]
>>> df_index = pd.MultiIndex.from_arrays(df_index_values)

On affecte le multi-index aux colonnes du dataframe:

>>> df.columns = df_index
>>> print(df)
  group1     group2    	
       a   b      c   d
0     a0  a1     a2  a3
1     b0  b1     b2  b3
2     c0  c1     c2  c3
3     d0  d1     d2  d3

Pour identifier une colonne, on doit utiliser un agrégat de valeurs:

>>> df.loc[1, ('group1', 'b')]
'b1'

On peut utiliser des multi-index sur n niveaux, par exemple sur 3 niveaux:

>>> df_index_values = [['A', 'B', 'B', 'C'], ['group1', 'group1', 'group2', 'group2'], ['a', 'b', 'c', 'd']]
>>> df_index = pd.MultiIndex.from_arrays(df_index_values)
>>> df.columns = df_index
>>> print(df)
       A      B             C
  group1 group1 group2 group2
       a      b      c      d
0     a0     a1     a2     a3
1     b0     b1     b2     b3
2     c0     c1     c2     c3
3     d0     d1     d2     d3

Accès aux éléments en utilisant un multi-index

On peut accéder aux éléments du dataframe en utilisant 1, 2 ou 3 niveaux:

>>> print(df.loc[:, 'B'])         # 1 niveau
  group1 group2
       b      c
0     a1     a2
1     b1     b2
2     c1     c2
3     d1     d2

>>> print(df.loc[:, ('B', 'group1')])         # 2 niveaux
    b
0  a1
1  b1
2  c1
3  d1

>>> df.loc[:, ('B', 'group1', 'b')]           # 3 niveaux
0    a1
1    b1
2    c1
3    d1
Name: (B, group1, b), dtype: object
On ne peut pas changer l’ordre des éléments dans le multi-index

Par exemple

>>> print(df.loc[:, ('B', 'group1')])         # OK
     b
 0  a1
 1  b1
 2  c1
 3  d1 
>>> df.loc[:, ('group1', 'B')]
KeyError: ('group1', 'B')

Utilisation de multi-index pour les lignes

On peut utiliser des multi-index pour les lignes:

>>> data = [['a0', 'a1', 'a2', 'a3'], ['b0', 'b1', 'b2', 'b3'], ['c0', 'c1', 'c2', 'c3'], ['d0', 'd1', 'd2', 'd3']]
>>> df = pd.DataFrame(data)
>>> df_index_values = [['A', 'A', 'B', 'B'], ['a', 'b', 'c', 'd']]
>>> df_index = pd.MultiIndex.from_arrays(df_index_values)
>>> df.index = df_index
>>> print(df)
      0   1   2   3
A a  a0  a1  a2  a3
  b  b0  b1  b2  b3
B c  c0  c1  c2  c3
  d  d0  d1  d2  d3

Création de multi-index à partir d’un tableau

Comme l’exemple précédent, on peut créer un multi-index à partir d’un tableau en indiquant directement les différents niveaux.

Par exemple pour 2 niveaux:

>>> df_index_values = [['A', 'A', 'B', 'B'], ['a', 'b', 'c', 'd']]
>>> df_index = pd.MultiIndex.from_arrays(df_index_values)

Si on affecte ce multi-index aux colonnes du dataframe d’origine:

>>> df.columns = df_index
>>> print(df)
    A       B    
    a   b   c   d
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

Création de multi-index à partir de tuples

La création de multi-index à partir de tuples est assez directe:

>>> df_index_values = [('A', 'a'), ('A', 'b'), ('B', 'c'), ('B', 'd')]
>>> df_index = pd.MultiIndex.from_tuples(df_index_values)

Si on affecte ce multi-index aux colonnes du dataframe d’origine, on obtient le même résultat que précédemment:

>>> df.columns = df_index
>>> print(df)
    A       B    
    a   b   c   d
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

Création de multi-index en effectuant un produit cartésien

Pour réduire la complexité de création d’un multi-index, il est possible d’effectuer un produit cartésien entre plusieurs valeurs pour obtenir les différents niveaux, par exemple:

>>> first_level = ['a', 'b']
>>> second_level = ['A', 'B']
>>> df_index = pd.MultiIndex.from_product([first_level, second_level])

Avec le dataframe d’origine, on obtient:

>>> df.columns = df_index
>>> print(df)
    a       b    
    A   B   A   B
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

Création de multi-index à partir d’un dataframe

Pour créer un dataframe à partir d’un dataframe

>>> df_multiindex = pd.DataFrame([['1', 'A'], ['1', 'B'], ['2', 'A'], ['2', 'B']])
>>> print(df_multiindex)
   0  1
0  1  A
1  1  B
2  2  A
3  2  B

>>> df_index = pd.MultiIndex.from_frame(df_multiindex)

Avec le dataframe d’origine, on obtient:

>>> df.columns = df_index
>>> print(df)
0   1       2    
1   A   B   A   B
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

Création de multi-index avec les arguments levels et codes

Les arguments levels et codes permettent d’indiquer de quelle façon les niveaux sont définis:

  • L’argument levels permet d’indiquer un tableau pour lequel chaque ligne contient les labels pour un niveau donné.
  • L’argument codes utilise un tableau pour lequel chaque ligne indique comment les labels sont utilisés par rapport aux colonnes du dataframe. Ces indications sont faites en indiquant un index de la ligne correspondante dans le tableau de l’argument levels.

Par exemple on souhaite définir un multi-index à 2 niveaux:

  • 1er niveau avec les labels '1' et '2'
  • 2e niveau avec les labels 'A' et 'B'.
    Le but étant d’avoir le multi-index suivant:

    0   1       2    
1   A   B   A   B

L’argument levels permettant de définir les niveaux contiendra le tableau suivant: [['1', '2'], ['A, 'B']].
L’argument codes va indiquer la façon dont les labels sont utilisés suivant les colonnes du dataframe. Sachant que le dataframe contient 4 colonnes donc chaque ligne du tableau de codes contiendra 4 éléments. Ces éléments indiquent l’index de la ligne dans levels à utiliser pour une colonne du dataframe:

  • Pour le 1er niveau: [0, 0, 1, 1] car 0 est l’index de '1' et 1 est l’index de '2' dans ['1', '2'].
  • Pour le 2e niveau: [0, 1, 0, 1] car 0 est l’index de 'A' et 1 est l’index de 'B' dans ['A', 'B'].

On définit le multi-index de cette façon:

df_index = pd.MultiIndex(levels = [['1', '2'], ['A', 'B']],
  codes = [[0, 0, 1, 1], [0, 1, 0, 1]])

Avec le dataframe d’origine, on obtient:

>>> df.columns = df_index
>>> print(df)
0   1       2    
1   A   B   A   B
0  a0  a1  a2  a3
1  b0  b1  b2  b3
2  c0  c1  c2  c3
3  d0  d1  d2  d3

Nommer les niveaux du multi-index

Pour plus de clarté, il est possible de nommer les différents niveaux du multi-index. Il faut utiliser le paramètre names lors de la création du multi-index.

Par exemple pour un multi-index à 3 niveaux:

>>> df_multiindex = pd.DataFrame([['1', 'A', 'a'], ['1', 'B', 'b'], ['2', 'A', 'c'], ['2', 'B', 'd']])
>>> print(df_multiindex)
   0  1  2
0  1  A  a
1  1  B  b
2  2  A  c
3  2  B  d

>>> df_index = pd.MultiIndex.from_frame(df_multiindex, names=['level1', 'level2', 'level3'])

En affectant ce multi-index au dataframe d’origine, on peut effectuer le nommage des différents niveaux:

>>> df.columns = df_index
>>> print(df)
level1   1       2    
level2   A   B   A   B
level3   a   b   c   d
0       a0  a1  a2  a3
1       b0  b1  b2  b3
2       c0  c1  c2  c3
3       d0  d1  d2  d3

Modifier un dataframe

Un dataframe est un objet mutable. On peut modifier des éléments d’un dataframe en utilisant les mêmes opérateurs ou fonctions utilisés pour accéder à ces éléments. En effet, ces opérateurs et fonctions permettent de renvoyer une référence de l’élément dans le dataframe, on peut donc aussi les utiliser pour modifier la valeur de l’élément.

Ainsi les syntaxes suivantes permettent de modifier un élément dans un dataframe:

  • <dataframe>[<index colonne>][<index ligne>] = <nouvelle valeur>
  • <dataframe>.loc[<index ligne>, <index colonne>] = <nouvelle valeur>
  • <dataframe>.iloc[<index ligne numérique>, <index colonne numérique>] = <nouvelle valeur>
  • <dataframe>.at[<index ligne>, <index colonne>] = <nouvelle valeur>
  • <dataframe>.iat[<index ligne numérique>, <index colonne numérique>] = <nouvelle valeur>

Par exemple, si on considère le dataframe suivant:

>>> data = {'a': ['a0', 'a1', 'a2'], 'b': ['b0', 'b1', 'b2'], 'c': ['c0', 'c1', 'c2']}
>>> i = ['l0', 'l1', 'l2']
>>> df = pd.DataFrame(data, index=i)
>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

Les syntaxes suivantes permettent de modifier les éléments dans le dataframe:

>>> df['a']['l1'] = 'NEW - a1'
>>> df.loc['l1', 'b'] = 'NEW - b1'
>>> df.iloc[1, 2] = 'NEW - c1'
>>> df.at['l2', 'a'] = 'NEW - a2'
>>> df.iloc[2, 1] = 'NEW - b2'
>>> print(df)
           a         b         c
l0        a0        b0        c0
l1  NEW - a1  NEW - b1  NEW - c1
l2  NEW - a2  NEW - b2        c2

On peut modifier une colonne entière en affectant une série. Il faut que la série utilise le même index que le dataframe, par exemple si on considère le dataframe d’origine dans l’exemple précédent:

>>> df['b'] = pd.Series(['NEW/b0', 'NEW/b1', 'NEW/b2'], index=i)
>>> print(df)
     a       b   c
l0  a0  NEW/b0  c0
l1  a1  NEW/b1  c1
l2  a2  NEW/b2  c2

Modifier les colonnes ou lignes

Renommer des lignes ou colonnes

On peut affecter de nouveaux labels pour les lignes ou les colonnes en utilisant les propriétés <dataframe>.index pour les lignes et <dataframe>.columns pour les colonnes.

Par exemple:

>>> df.columns = ['A', 'B', 'C']
>>> df.index = ['1', '2', '3']
>>> print(df)
    A   B   C
1  a0  b0  c0
2  a1  b1  c1
3  a2  b2  c2

Pour renommer un ou plusieurs noms de lignes/colonnes sans tout modifier, on peut utiliser <dataframe>.rename() mais il ne faut pas oublier l’argument inplace=True car rename() renvoie un nouveau dataframe.

Par exemple:

>>> df.rename(columns = {'a': 'B'}, index = {'l1': 'n1'}, inplace=True)
>>> print(df)
     A   b   c
l0  a0  b0  c0
n1  a1  b1  c1
l2  a2  b2  c2

Ajouter une colonne

On peut ajouter une colonne en affectant une série dans un label de colonne qui n’existe pas. Il faut que l’index de la série soit le même que celui du dataframe.

Par exemple:

>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2
>>> df['d'] = pd.Series(['d0', 'd1', 'd2'], index=['l0', 'l1', 'l2'])
>>> print(df)
     a   b   c   d
l0  a0  b0  c0  d0
l1  a1  b1  c1  d1
l2  a2  b2  c2  d2

Si on crée la nouvelle colonne de la façon suivante, toutes les valeurs de la colonne contiendront la même valeur:

>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2
>>> df['d'] = 'NEW'
>>> print(df)
     a   b   c    d
l0  a0  b0  c0  NEW
l1  a1  b1  c1  NEW
l2  a2  b2  c2  NEW

<dataframe>.assign()

On peut utiliser une autre syntaxe avec assign() pour ajouter une nouvelle colonne. assign() renvoie un nouveau dataframe, il n’est pas possible d’utiliser un argument inplace.

Par exemple:

>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2
>>> new_column = pd.Series(['NEW/b0', 'NEW/b1', 'NEW/b2'], index=i)
>>> new_df = df.assign(d = new_column)
>>> print(new_df)
     a   b   c       d
l0  a0  b0  c0  NEW/b0
l1  a1  b1  c1  NEW/b1
l2  a2  b2  c2  NEW/b2

Ajouter une colonne à un index donné

Avec <dataframe>.insert(), on peut ajouter une colonne à un index particulier dans un dataframe existant en utilisant la syntaxe:

<dataframe>.insert(<index>, <nom nouvelle colonne>, <nouveaux éléments>)

Par exemple:

>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2
>>> df.insert(1, 'd', ['NEW/d0', 'NEW/d1', 'NEW/d2'])
>>> print(df)
     a       d   b   c
l0  a0  NEW/d0  b0  c0
l1  a1  NEW/d1  b1  c1
l2  a2  NEW/d2  b2  c2

Changer l’ordre des colonnes

Avec reindex(), on peut réordonner les colonnes d’un dataframe. La fonction génère un nouveau dataframe:

<dataframe>.reindex(columns=['<colonne 1>', '<colonne 2>', ..., '<colonne N>'])

On peut utiliser l’option copy=False pour éviter de générer un nouveau dataframe.

Par exemple:

>>> printf(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

>>> new_df = df.reindex(columns=['c', 'b', 'a'])
>>> print(new_df)
     c   b   a
l0  c0  b0  a0
l1  c1  b1  a1
l2  c2  b2  a2

Une autre méthode est d’utiliser cette syntaxe (le résultat est le même):

>>> new_df = df[['c', 'b', 'a']]

Supprimer des colonnes

Plusieurs syntaxes sont possibles pour supprimer une ou plusieurs colonnes. Pour supprimer une colonne dans un dataframe en modifiant l’instance directement: 

del <dataframe>['<colonne i>']

Par exemple:

>>> printf(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

>>> del df['c']
>>> print(df)
     a   b
l0  a0  b0
l1  a1  b1
l2  a2  b2

Les syntaxes suivantes sont équivalentes et permettent de supprimer plusieurs colonnes en générant un nouveau dataframe. Le dataframe courant n’est pas modifié. Pour modifier le dataframe courant, il faut rajouter l’option inplace = True.

  • <dataframe>.drop(['<colonne x>', '<colonne y>', '<colonne z>'], axis = 1)
  • <dataframe>.drop(columns = ['<colonne x>', '<colonne y>', '<colonne z>'])

La fonction <dataframe>.pop('<colonne i>') permet de supprimer une colonne et de renvoyer la série correspondant à la colonne supprimée.

Par exemple:

>>> print(df)
     a   b   c
l0  a0  b0  c0
l1  a1  b1  c1
l2  a2  b2  c2

>>> deleted_column = df.pop('b')
>>> deleted_column
l0    b0
l1    b1
l2    b2
Name: b, dtype: object

Supprimer des lignes

Les syntaxes suivantes permettent de supprimer des lignes d’un dataframe en générant un nouveau dataframe. Le dataframe courant n’est pas modifié. Pour modifier le dataframe courant, il faut rajouter l’option inplace = True.

  • <dataframe>.drop(['<ligne x>', '<ligne y>', '<ligne z>'])
  • <dataframe>.drop(index = ['<ligne x>', '<ligne y>', '<ligne z>'])

Modification de valeurs d’un dataframe

De nombreuses fonctions existent pour modifier directement un dataframe sans avoir à exécuter une boucle pour parcourir toutes les valeurs du dataframe:

  • <dataframe>.astype(<nouveau type>): modifie le type de toutes les valeurs d’un dataframe en générant un nouveau dataframe. Le type est le même que celui indiqué lors de l’initialisation. On peut utiliser l’option copy=False pour modifier le dataframe courant au lieu de générer un nouveau dataframe.
  • <dataframe>.astype({'colonne x': <type 1>, 'colonne y': <type 2>, 'colonne z': <type 3>}): permet de modifier le type de plusieurs colonnes. Le type est le même que celui indiqué lors de l’initialisation. On peut utiliser l’option copy=False pour modifier le dataframe courant au lieu de générer un nouveau dataframe.
  • <dataframe>.replace(<valeur à remplacer>, <valeur remplaçante>): permet de remplacer toute occurence d’une valeur dans un dataframe par une autre. Cette fonction génère un nouveau dataframe, pour modifier le dataframe courant, il faut utiliser l’option: inplace=True.

    On peut utiliser des syntaxes différentes pour effectuer plusieurs remplacements en une fois:

    • <dataframe>.replace([<valeur à remplacer 1>, <valeur remplaçante 1>], [<valeur à remplacer 2>, <valeur remplaçante 2>], [<valeur à remplacer 3>, <valeur remplaçante 3>])
    • <dataframe>.replace({<valeur à remplacer 1>: <valeur remplaçante 1>, <valeur à remplacer 2>: <valeur remplaçante 2>, <valeur à remplacer 3>: <valeur remplaçante 3>)
  • <dataframe>.fillna(<valeur remplaçante>): remplacer tous les NaN par une valeur particulière. Cette fonction génère un nouveau dataframe, pour modifier le dataframe courant, il faut utiliser l’option: inplace=True.
  • <dataframe>.dropna(): supprime toutes les lignes contenant au moins une valeur NaN. Un nouveau dataframe est renvoyé, le dataframe courant n’est pas modifié. On peut utiliser les options suivantes:
    • how = 'all': une ligne est supprimée si toutes les valeurs de cette ligne sont NaN.
    • inplace=True pour modifier le dataframe courant.
    • axis = 1 pour supprimer les colonnes contenant des valeurs NaN plutôt que des lignes.
  • <dataframe>.apply(<lambda>): applique une lambda à toutes les valeurs d’un dataframe. Le dataframe courant n’est pas modifié, le type de la sortie dépend des options.

    Par exemple, on considère le dataframe suivant:

    >>> df = pd.DataFrame({'a': [2, 3, 4], 'b': [5, 6, 7], 'c': [8, 9, 10]}, 
	index=['l0', 'l1', 'l2'])
>>> print(df)
    a  b   c
l0  2  5   8
l1  3  6   9
l2  4  7  10
    • Par défaut et sans option, la lambda est exécutée pour chaque valeur du dataframe d’origine: 
      >>> print(df.apply(lambda x: x ** 2))
     a   b    c
l0   4  25   64
l1   9  36   81
l2  16  49  100

      La taille et la structure du dataframe d’origine sont maintenues.

    • Avec l’option axis = 0: la lambda est appliquée sur chaque colonne. Le type de l’objet passé en paramètre de la lambda est une série. La sortie de la lambda n’est pas forcément dans la même dimension que l’entrée: 
      >>> print(df.apply(lambda x: x['l0'] + x['l1'] + x['l2'], axis = 0))
a     9
b    18
c    27
dtype: int64

      La traitement se fait en colonne (par série). La sortie de la lambda est une valeur scalaire alors la sortie de df.apply() est une série.

      >>> print(df.apply(lambda x: [x['l0'], x['l1']], axis = 0))
   a  b  c
0  2  5  8
1  3  6  9

      La sortie de la lambda est un tableau avec 2 valeurs donc la sortie de df.apply() est un dataframe à 2 lignes. La dimension de l’objet en sortie dépend de la sortie de la lambda.

    • Avec l’option axis = 1: la lambda est appliquée sur chaque ligne. Le type de l’objet passé en paramètre de la lambda est une série. La sortie de la lambda n’est pas forcément dans la même dimension que l’entrée: 
      >>> print(df.apply(lambda x: x['a'] + x['b'] + x['c'], axis = 1))
l0    15
l1    18
l2    21
dtype: int64

      La traitement se fait en ligne. La sortie de la lambda est une valeur scalaire alors la sortie de df.apply() est une série.

      >>> print(df.apply(lambda x: pd.Series([x['a'], x['b']]), axis = 1))
    0  1
l0  2  5
l1  3  6
l2  4  7

      Si la sortie de la lambda est une série, alors la sortie de df.apply() sera un dataframe.

      Pour avoir des labels de colonnes particuliers il faut indiquer un index dans la série en sortie de la lambda:

      >>> print(df.apply(lambda x: pd.Series([x['a'], x['b']], index=['c0', 'c1']), axis = 1))
    c0  c1
l0   2   5
l1   3   6
l2   4   7

>>> print(df.apply(lambda x: [x['a'], x['b']], axis = 1))
l0    [2, 5]
l1    [3, 6]
l2    [4, 7]
dtype: object

      Si la sortie de la lambda est un tableau, alors la sortie de df.apply() est une série de tableaux.

    • result_type = 'expand' permet d’indiquer que la sortie de la lambda sera considérée comme des colonnes. Si on renvoie un tableau alors les éléments du tableau seront des colonnes: 
      >>> print(df.apply(lambda x: [x['a'], x['b']], axis = 1, result_type='expand'))
    0  1
l0  2  5
l1  3  6
l2  4  7

      Chaque élément du tableau de sortie de la lambda est considéré comme un élément de colonne du dataframe en sortie. Les labels des colonnes d’origine sont toutefois perdus.

    • result_type = 'reduce' permet d’indiquer que la sortie de la lambda sera considérée comme une réduction des colonnes du dataframe d’origine. Si la lambda renvoie un tableau, la sortie de df.apply() sera une série de tableau: 
      >>> print(df.apply(lambda x: [x['a'], x['b']], axis = 1, result_type='reduce'))
l0    [2, 5]
l1    [3, 6]
l2    [4, 7]
dtype: object
    • result_type = 'broadcast' permet d’indiquer que la structure du dataframe d’origine sera préservée donc les labels des colonnes seront maintenus en sortie. Il n’est pas nécessaire que la lambda génère une série ou d’indiquer des index en sortie de la lambda: 
      >>> print(df.apply(lambda x: [x['a'], x['b'], x['c']], axis = 1, result_type='broadcast'))
    a  b   c
l0  2  5   8
l1  3  6   9
l2  4  7  10

      Les labels des colonnes sont maintenus dans le dataframe en sortie.

Modifier les valeurs d’un dataframe par condition

Il est possible de modifier plusieurs valeurs d’un dataframe en une seule ligne en indiquant des conditions.

Par exemple, si on considère le dataframe suivant:

>>> df = pd.DataFrame({'a': [2, 3, 4], 'b': [5, 6, 7], 'c': [8, 9, 10]}, 
	index=['l0', 'l1', 'l2'])
>>> print(df)
    a  b   c
l0  2  5   8
l1  3  6   9
l2  4  7  10

On peut modifier toutes les valeurs d’une colonne de cette façon:

>>> df['b'] = 0
>>> print(df)
    a  b   c
l0  2  0   8
l1  3  0   9
l2  4  0  10

On peut indiquer une condition valable pour toutes les valeurs du dataframe:

>>> print(df)
    a  b   c
l0  2  5   8
l1  3  6   9
l2  4  7  10

>>> df[df > 6] = 0
>>> print(df)
    a  b  c
l0  2  5  0
l1  3  6  0
l2  4  0  0

On affectera 0 à toutes les valeurs strictement supérieures à 6.

On peut aussi modifier une colonne suivant des conditions appliquées sur d’autres colonnes. Par exemple, si un élément de la colonne 'a' >= 3 alors on affecte 0 à l’élément de la même ligne dans la colonne 'b':

>>> print(df)
    a  b   c
l0  2  5   8
l1  3  6   9
l2  4  7  10

>>> df.loc[df['a'] >= 3,'b'] = 0
>>> print(df)
    a  b   c
l0  2  5   8
l1  3  0   9
l2  4  0  10

Modifier un dataframe en appliquant des fonctions

<dataframe>.drop_duplicates()

Cette fonction permet de supprimer les lignes redondantes dans un dataframe et de ne conserver qu’une seule occurence. Par défaut, la fonction renvoie un dataframe avec les duplicats supprimés. Cette fonction peut être utilisée avec les options suivantes:

  • inplace = True: permet de modifier le dataframe courant plutôt que de renvoyer un dataframe avec les modifications.
  • keep = False pour ne pas conserver au moins une ligne parmi les duplicats. keep = 'last' permet de ne conserver que la dernière occurence parmi les duplicats et keep = 'first' est la valeur par défaut, seule la 1ère occurence est conservée.
  • subset = [<nom des colonnes>]: permet d’indiquer quelles sont les colonnes à vérifier pour trouver les duplicats. Par défaut, toutes les colonnes sont vérifiées.

Par exemple, si on considère le dataframe suivant:

>>> df = pd.DataFrame([['1', 'A', 'a'], ['1', 'B', 'b'], ['1', 'B', 'c'], ['2', 'A', 'c'], ['2', 'B', 'd'], ['2', 'B', 'd']])
>>> print(df)
0  1  2
0  1  A  a
1  1  B  b
2  1  B  c
3  2  A  c
4  2  B  d
5  2  B  d

Par défaut, toutes les colonnes sont vérifiées et seule la 1ère occurence est conservée:

>>> print(df.drop_duplicates())
   0  1  2
0  1  A  a
1  1  B  b
2  1  B  c
3  2  A  c
4  2  B  d

Avec subset = [0], seule la colonne 0 est vérifiée pour trouver les duplicats:

>>> print(df.drop_duplicates(subset = [0]))
   0  1  2
0  1  A  a
3  2  A  c

Avec keep = 'last', les duplicats sont cherchés en vérifiant la colonne 0 et on ne garde que la dernière occurence. 

>>> print(df.drop_duplicates(subset = [0], keep = 'last'))
   0  1  2
2  1  B  c
5  2  B  d

Tri des index et colonnes avec <dataframe>.sort_index()

<dataframe>.sort_index() permet de trier les éléments d’un dataframe suivant les index ou les colonnes. Par défaut le tri se fait dans le sens ascendant sur les index et en générant un nouveau dataframe. On peut utiliser les options suivantes:

  • inplace = True pour modifier le dataframe courant.
  • ascending = False pour trier par ordre décroissant.
  • axis=1 pour trier suivant les noms de colonnes.
  • level = <int> pour indiquer le niveau à trier dans le cas d’un index multi-niveau.

Par exemple:

>>> df = pd.DataFrame([['1', 'A', 'a'], ['1', 'B', 'b'], ['1', 'C', 'c']], 
                  columns = ['c', 'b', 'a'], 
                  index = ['z', 'y', 'x'])
>>> print(df)
   c  b  a
z  1  A  a
y  1  B  b
x  1  C  c

>>> print(df.sort_index())
   c  b  a
x  1  C  c
y  1  B  b
z  1  A  a

>>> print(df.sort_index(axis=1, ascending=True))
   a  b  c
z  a  A  1
y  b  B  1
x  c  C  1

Tri des valeurs avec <dataframe>.sort_values()

<dataframe>.sort_values() permet de trier les valeurs d’un dataframe. Il faut indiquer la colonne ou les colonnes à trier avec l’argument by. Par défaut le tri se fait dans le sens ascendant en générant un nouveau dataframe. On peut utiliser les options suivantes:

  • inplace = True pour modifier le dataframe courant.
  • ascending = False pour trier par ordre décroissant.
  • axis=1 pour trier suivant les noms de colonnes.
  • na_position indique où les valeurs NaN seront placées:
    • 'first': elles seront placées avant les valeurs triées
    • 'last': elles seront placées après les valeurs triées
  • key: permet d’indiquer une lambda qui sera utilisée pour appliquer un tri particulier sur les colonnes indiquées avec by. Le type de la valeur d’entrée de la lambda sera une série.

Par exemple:

>>> df = pd.DataFrame([['1', 'A', 'a', np.NaN], ['2', 'B', 'b', '0'], ['3', 'C', 'c', '1'], ['4', 'D', 'd', np.NaN]], 
                  columns = ['a', 'b', 'c', 'd'], 
                  index = ['w', 'x', 'y', 'z'])
>>> print(df)
   a  b  c    d
w  1  A  a  NaN
x  2  B  b    0
y  3  C  c    1
z  4  D  d  NaN

>>> print(df.sort_values(by = 'd', na_position='first'))
   a  b  c    d
w  1  A  a  NaN
z  4  D  d  NaN
x  2  B  b    0
y  3  C  c    1

On trie suivant la colonne 'd' et on place les valeurs NaN avant les valeurs triées. 

>>> print(df.sort_values(by = ['d', 'c'], na_position='last'))
   a  b  c    d
0  2  B  b    0
1  3  C  c    1
2  1  A  a  NaN
3  4  D  d  NaN

On trie suivant 2 colonnes 'd' et 'c' et on place les valeurs NaN après les valeurs triées. 

>>> print(df.sort_values(by = ['a'], key=lambda x: x.apply(lambda y: -int(y))))
   a  b  c    d
z  4  D  d  NaN
y  3  C  c    1
x  2  B  b    0
w  1  A  a  NaN

On effectue le tri suivant la colonne 'a' et on applique la lambda x: x.apply(lambda y: -int(y)) à la colonne 'a' avant d’effectuer le tri. x dans la lambda est une série. x.apply() permet d’appliquer une autre lambda aux valeurs de la série.

La série est entrée de la lambda est:

>>> df['a']
w    1
x    2
y    3
z    4
Name: a, dtype: object

Après application de la lambda:

>>> df['a'].apply(lambda y: -int(y))
w   -1
x   -2
y   -3
z   -4
Name: a, dtype: int64

Agrégation

Avec <dataframe>.groupby()

La fonction <dataframe>.groupby() permet de calculer des agrégats suivant une colonne, plusieurs colonnes ou suivant un mapping particulier. L’argument by permet d’indiquer les groupes des agrégats en indiquant:

  • Une colonne: <dataframe>.groupby([<nom colonne>])
  • Plusieurs colonnes: <dataframe>.groupby([<nom colonne 1>, <nom colonne 2>, ... , <nom colonne i>])
  • Une fonction de mapping: <dataframe>.groupby(<fonction effectuant le mapping>)

Il est possible d’affiner les critères du groupby en précisant certains arguments:

  • axis=1 pour trier suivant les noms de colonnes.
  • level = <int> pour indiquer le niveau à trier dans le cas d’un index multi-niveau.
  • sort=False pour ne pas trier les groupes.
  • group_keys=True: si on utilise apply() en sortie du groupby(), cet argument permet d’indiquer si on veut rajouter un index indiquant les clés de groupage.
  • dropna=False pour ne pas ignorer les valeurs NaN.

Le type de retour de la fonction <dataframe>.groupby() est pandas.core.groupby.generic.DataFrameGroupBy. Ce type autorise d’appliquer des méthodes lors de l’agrégation. Si la colonne ne permet pas l’agrégation, elle sera ignorée:

  • size() pour préciser le nombre de lignes par groupe.
  • sum() pour sommer les valeurs des groupes. Les colonnes où une somme n’est pas possible seront ignorées.
  • min() pour indiquer le minimum des valeurs groupées.
  • max() pour indiquer le maximum des valeurs groupées.
  • describe() pour générer des statistiques descriptives.
  • count() pour compter le nombre de groupes.
  • first() pour renvoyer la 1ère ligne de chaque groupe.
  • last() pour renvoyer la dernière ligne de chaque groupe.
  • nth() pour renvoyer la n-ième ligne de chaque groupe.
  • std() pour renvoyer l’écart-type (i.e. standard déviation) pour chaque groupe.
  • var() pour renvoyer la variance pour chaque groupe.
  • sem() pour renvoyer l’erreur type de la moyenne pour chaque groupe.
  • apply(<lambda>) pour effectuer un traitement sur les groupes d’agrégation.

Par exemple:

>>> df = pd.DataFrame([['1', 'A', 10, np.NaN], ['2', 'B', 15, 3], ['1', 'B', 5, 1], ['2', 'D', 35, np.NaN], ['2', 'A', 25, 3]], 
                  columns = ['a', 'b', 'c', 'd'])
>>> print(df)
   a  b   c    d
0  1  A  10  NaN
1  2  B  15  3.0
2  1  B   5  1.0
3  2  D  35  NaN
4  2  A  25  3.0

>>> df.groupby(['a'])
<pandas.core.groupby.generic.DataFrameGroupBy object at 0xffff58e920d0>

Le résultat d’une agrégation est de type DataFrameGroupBy sur lequel on peut appliquer les fonctions d’agrégation:

>>> print(df.groupby(['a']).sum())
    c    d
a         
1  15  1.0
2  75  6.0

La somme est effectuée sur les colonnes où c’est possible. Les autres colonnes sont ignorées.

>>> print(df.groupby(['a', 'b']).sum())
      c    d
a b         
1 A  10  0.0
  B   5  1.0
2 A  25  3.0
  B  15  3.0
  D  35  0.0

On peut effectuer l’agrégation sur plusieurs colonnes. Le dataframe résultant contient un index multi-niveau.

Si on applique l’agrégation suivant la colonne 'd', inclure ou non les valeurs NaN produit des résultats différents:

>>> print(df.groupby(['d']).sum())
      c
d      
1.0   5
3.0  40

>>> print(df.groupby(['d'], dropna=False).sum())
      c
d      
1.0   5
3.0  40
NaN  45

Si on effectue des agrégations en indiquant une fonction:

>>> def make_group(input_value):
    if input_value < 2:
        return 'group1'
    elif input_value == 2:
        return 'group2'
    else:
        return 'group3'
>>> print(df.groupby(make_group).sum())
         c    d
group1  25  3.0
group2   5  1.0
group3  60  3.0

Si on applique la fonction d’agrégation avec apply():

>>> df.groupby(['a']).apply(lambda x: x['b'])
a   
1  0    A
   2    B
2  1    B
   3    D
   4    A
Name: b, dtype: object

Le résultat est sous la forme d’une série avec un index multi-niveau. On peut éviter d’avoir un index correspondant à la clé d’agrégation avec l’option group_keys=False:

>>> df.groupby(['a'], group_keys=False).apply(lambda x: x['b'])
0    A
2    B
1    B
3    D
4    A
Name: b, dtype: object

Fonction d’agrégation aggregate() ou agg()

La fonction aggregate() ou agg() permet d’appliquer un traitement plus sophistiquée sur des agrégations. Elle s’applique sur un type pandas.core.groupby.generic.DataFrameGroupBy à la suite d’une fonction <dataframe>.groupby().

La fonction aggregate() ou agg() prend comme argument:

  • Une fonction, par exemple np.sum pour effectuer une somme des agrégats ou,
  • Une chaine de caractère indiquant le nom d’une fonction, par exemple 'sum' ou,
  • Une liste de fonctions à appliquer en indiquant directement la fonction ou en indiquant son nom, par exemple [np.mean, 'sum'] et,
  • Un dictionnaire permettant d’indiquer un nom de colonne et la fonction à appliquer et,
  • Des indications sur le nom de la colonne résultante, la colonne du dataframe où la fonction s’applique et la fonction à appliquer.

On peut utiliser les mêmes fonctions d’agrégation que celles indiquées plus haut:

  • np.size ou 'size' pour préciser le nombre de lignes par groupe.
  • np.sum ou 'sum' pour sommer les valeurs des groupes. Les colonnes où une somme n’est pas possible seront ignorées.
  • np.min ou 'min' pour indiquer le minimum des valeurs groupées.
  • np.max ou 'max' pour indiquer le maximum des valeurs groupées.
  • 'describe' pour générer des statistiques descriptives.
  • 'count' pour compter le nombre de groupes.
  • 'first' pour renvoyer la 1ère ligne de chaque groupe.
  • 'last' pour renvoyer la dernière ligne de chaque groupe.
  • np.std ou 'std' pour renvoyer l’écart-type (i.e. standard déviation) pour chaque groupe.
  • np.var ou 'var' pour renvoyer la variance pour chaque groupe.
  • 'sem' pour renvoyer l’erreur type de la moyenne pour chaque groupe.

Par exemple, si on considère le dataframe suivant:

>>> df = pd.DataFrame([['1', 'A', 10, np.NaN], ['2', 'B', 15, 3], ['1', 'B', 5, 1], ['2', 'D', 35, np.NaN], ['2', 'A', 25, 3]], 
                  columns = ['a', 'b', 'c', 'd'])
>>> print(df)
   a  b   c    d
0  1  A  10  NaN
1  2  B  15  3.0
2  1  B   5  1.0
3  2  D  35  NaN
4  2  A  25  3.0

On peut effectuer une agrégation sur une colonne et effectuer la somme du contenu des autres colonnes en indiquant directement la fonction à exécuter:

>>> print(df.groupby(['a']).agg(np.sum))
    c    d
a         
1  15  1.0
2  75  6.0

En indiquant le nom de la fonction:

>>> print(df.groupby(['a']).agg('sum'))
    c    d
a         
1  15  1.0
2  75  6.0

En indiquant plusieurs fonctions à exécuter dans une liste (les fonctions s’appliquent à toutes les colonnes):

>>> print(df.groupby(['a']).agg([np.mean, 'sum']))
      c        d     
   mean sum mean  sum
a                    
1   7.5  15  1.0  1.0
2  25.0  75  3.0  6.0

En utilisant un dictionnaire, on peut indiquer la colonne sur laquelle on souhaite appliquer une fonction:

>>> print(df.groupby(['a']).agg({'c': np.mean, 'd': 'sum'}))
      c    d
a           
1   7.5  1.0
2  25.0  6.0

On peut créer de nouvelles colonnes en indiquant le nom de la colonne résultante, la colonne du dataframe où la fonction s’applique et la fonction à appliquer:

>>> print(df.groupby(['a']).agg(moyenne_c = ('c', np.mean), sum_d = ('d', 'sum')))
   moyenne_c  sum_d
a                  
1        7.5    1.0
2       25.0    6.0

Fonctions mathématiques

Pour les fonctions suivantes, l’opération est appliquée, par défaut, pour chaque colonne. Le résultat est renvoyé sous la forme d’une série.
Pour que l’opération soit effectuée suivant les lignes, il faut utiliser l’argument axis = 1.

Quelques fonctions:

Fonction Explication
<dataframe>.mean() Moyenne des valeurs de chaque colonne.
<dataframe>.median() Moyenne médiane des valeurs de chaque colonne.
<dataframe>.min() Minimum pour chaque colonne.
<dataframe>.max() Maximum pour chaque colonne.
<dataframe>.std() Ecart-type pour chaque colonne.
<dataframe>.var() Variance pour chaque colonne.
<dataframe>.idxmax() Index du maximum de chaque colonne.
<dataframe>.idxmin() Index du minimim de chaque colonne.
<dataframe>.transpose() ou <dataframe>.T Transposée du dataframe.
<dataframe>.round(<nombre de décimales>) Arrondi de toutes les valeurs du dataframe.
<dataframe>.abs() Valeur absolue des valeurs numériques.

Opérations sur les dataframes

Lorsque qu’une opération parmi les opérations suivantes est appliquée sur des dataframes pandas, les opérations ne sont pas appliquées au sens mathématique comme s’il s’agissait de matrices: l’opération est appliquée sur chaque élément du dataframe. Dans le cas où 2 dataframes sont concernés, les calculs sont appliqués entre les éléments des dataframes situés à la même position.

Par exemple si on considère 2 dataframes:

>>> df1 = pd.DataFrame([[1, 2, 3, 4], [10, 20, 30, 40], [100, 200, 300, 400], [1000, 2000, 3000, 4000]])
>>> print(df1)
     0     1     2     3
0    1     2     3     4
1   10    20    30    40
2  100   200   300   400
3 1000  2000  3000  4000
     
>>> df2 = pd.DataFrame([[1, 2, 3, 4], [11, 21, 31, 41], [101, 201, 301, 401], [1001, 2001, 3001, 4001]])
>>> print(df2)
      0     1     2     3
0     1     2     3     4
1    10    20    30    40
2   100   200   300   400
3  1000  2000  3000  4000

Si on applique l’opération df1 * df2, on peut voir qu’il ne s’agit pas d’une multiplication de matrice:

>>> print(df1 * df2)
         0        1        2         3
0        1        4        9        16
1      110      420      930      1640
2    10100    40200    90300    160400
3  1001000  4002000  9003000  16004000

Les opérations suivantes sont applicables:

  • Les opérations arithmétiques classiques:
    • + ou <dataframe1>.add(<dataframe2>),
    • - ou <dataframe1>.sub(<dataframe2>),
    • / ou <dataframe1>.div(<dataframe2>),
    • * ou <dataframe1>.mul(<dataframe2>),
    • // pour la division entière et
    • % ou <dataframe1>.mod(<opérande>) pour le reste de la division entière.
  • <dataframe> ** 2 ou <dataframe>.pow(2) pour le carré
  • Les opérations booléennes en utilisant:
    • & pour “and”,
    • | pour “ou”,
    • ~ ou – pour “not”,
    • ^ pour le “ou exclusif”.
  • Les opérateurs de comparaison:
    • == ou <dataframe1>.eq(<dataframe2>) pour tester l’égalité,
    • != ou <dataframe1>.ne(<dataframe2>) pour tester l’inégalité,
    • < ou <dataframe1>.lt(<dataframe2>),
    • > ou <dataframe1>.gt(<dataframe2>),
    • <= ou <dataframe1>.le(<dataframe2>),
    • >= ou <dataframe1>.ge(<dataframe2>).
ne pas confondre eq() et equals()

eq() compare tous les éléments de 2 dataframes et renvoie un dataframe de même taille avec des booléens résultant de la comparaison de tous les éléments.
equals() compare tous les éléments des 2 dataframes et ne renvoient qu’un seul booléen qui est True si tous les éléments des dataframes sont égaux.

Si on prend les dataframes précédents:

>>> print(df1.eq(df2))
       0      1      2      3
0   True   True   True   True
1  False  False  False  False
2  False  False  False  False
3  False  False  False  False

>>> df1.equals(df2)
False

Opérations entre un dataframe et un autre type d’objet

Les opérations ne sont pas exclusivement réservées aux dataframes entre eux. On peut appliquer des opérations entre:

  • Un dataframe et un scalaire: l’opération avec le scalaire est appliquée sur tous les éléments.

    Par exemple:

    >>> df1 = pd.DataFrame([[1, 2, 3], [10, 20, 30], [100, 200, 300]], index = ['a', 'b', 'c'])
>>> print(df1 * 3)
     0    1    2
a    3    6    9
b   30   60   90
c  300  600  900
  • Un dataframe et une liste: la taille de la liste doit être de la même taille que la dimension du dataframe sur laquelle l’opération est appliquée. L’opération est appliquée sur toutes les lignes ou toutes les colonnes suivant le sens d’application de l’opération.

    Par exemple:

    >>> print(df1 + [5, 15, 25])
     0    1    2
a    6   17   28
b   15   35   55
c  105  215  325

    Dans le cas précédent, l’addition des éléments de la liste est appliquée sur toutes les lignes.
    Le résultat est le même en exécutant df1.add([5, 15, 25], axis=1) ou df1.add([5, 15, 25], axis='columns').

    Dans le cas suivant, l’opération avec la liste est appliquée sur toutes les colonnes:

    >>> print(df1.add([5, 15, 25], axis=0)) 
     0    1    2
a    6    7    8
b   25   35   45
c  125  225  325

    Une autre syntaxe équivalente est: df1.add([5, 15, 25], axis='index').

  • Un dataframe et une série pandas: l’opération est appliquée sur les labels communs. Si des labels ne sont pas communs, la valeur résultante est NaN.

    Par exemple:

    >>> s = pd.Series([5, 15, 25]
>>> print(df1 + s)
     0    1    2
a    6   17   28
b   15   35   55
c  105  215  325

    L’opération est appliquée dans le sens des lignes. Les labels utilisés sont les labels par défaut. 

    >>> print(df1 + pd.Series([5, 15])
       0      1   2
a    6.0   17.0 NaN
b   15.0   35.0 NaN
c  105.0  215.0 NaN

    La série ne possède pas le label 2 donc la colonne 2 n’est pas commune aux 2 objets et la valeur affectée est NaN.

    Dans l’exemple suivant, l’opération est appliquée en colonne:

    >>> print(df1.add(pd.Series([5, 15, 25], index=['a', 'b', 'c']), axis=0))
     0    1    2
a    6    7    8
b   25   35   45
c  125  225  325

    Il faut indiquer les mêmes labels que le dataframe pour que l’opération soit possible.

  • Un dataframe et un dictionnaire: l’opération est appliquée pour les éléments du dictionnaire pour lesquels la clé correspond à un index du dataframe.

    Par exemple, dans le cas suivant l’opération est appliquée dans le sens des lignes:

    >>> d = {0: 5, 1: 15, 2: 25}
>>> print(df1 + d)
     0    1    2
a    6   17   28
b   15   35   55
c  105  215  325

    Dans le cas suivant, l’opération est appliquée dans le sens des colonnes. 

    >>> d = {'a': 5, 'b': 15, 'c': 25}
>>> print(df1.add(d, axis=0))
     0    1    2
a    6    7    8
b   25   35   45
c  125  225  325

Argument fill_value

On peut utiliser l’argument fill_value pour indiquer la valeur à appliquer lorsque les index qui ne sont pas communs.

Par exemple:

>>> df1 = pd.DataFrame([[1, 2, 3], [10, 20, 30], [100, 200, 300]], index = ['a', 'b', 'c'])
>>> df2 = pd.DataFrame([[1, 2, 3], [11, 21, 31], [101, 201, 301]], index = ['a', 'b', 'd'])
>>> print(df1.add(df2))
      0     1     2
a   2.0   4.0   6.0
b  21.0  41.0  61.0
c   NaN   NaN   NaN
d   NaN   NaN   NaN

La valeur NaN est appliquée lorsque les index ne sont pas communs. 

>>> print(df1.add(df2, fill_value=0))
       0      1      2
a    2.0    4.0    6.0
b   21.0   41.0   61.0
c  100.0  200.0  300.0
d  101.0  201.0  301.0

Les index 'c' et 'd' ne sont pas communs entre les 2 dataframes. La valeur 0 est utilisée lorsque les index ne sont pas communs.

Opérations avec des index ou des colonnes non communs

Les opérations sont appliquées si les labels des dataframes sont les mêmes. Dans les exemples suivants, les labels utilisés sont les labels par défaut. Si certains labels ne sont pas égaux alors le résultat est NaN pour les éléments ayant des labels différents.

Par exemple si on considère les dataframes suivants:

>>> df1 = pd.DataFrame([[1, 2, 3], [10, 20, 30], [100, 200, 300]], columns = ['a', 'b', 'c'])
>>> df2 = pd.DataFrame([[1, 2, 3], [11, 21, 31], [101, 201, 301]], columns = ['a', 'b', 'd'])
>>> print(df1 + df2)
     a    b   c   d
0    2    4 NaN NaN
1   21   41 NaN NaN
2  201  401 NaN NaN

Les colonnes non communes contiennent NaN.

Jointures

Il est possible d’utiliser la fonction merge() pour effectuer des jointures entre 2 dataframes ayant au moins une colonne en commun et obtenir un dataframe avec le résultat de cette jointure.

Par exemple:

>>> df1 = pd.DataFrame({'id': [2, 1, 5], 'value1': [100, 165, 628]}); 
>>> print(df1)
   id  value1
0   2     100
1   1     165
2   5     628

>>> df2 = pd.DataFrame({'id': [1, 2, 8, 10], 'value2': [92, 27, 87, 43]});
>>> print(df2)
   id  value2
0   1      92
1   2      27
2   8      87
3  10      43

>>> print(df1.merge(df2))
   id  value1  value2
0   2     100      27
1   1     165      92

La jointure est effectuée sur la colonne id puisque c’est la seule colonne commune. Les valeurs 1 et 2 dans cette colonne sont communes.
merge() peut être utilisé avec les options suivantes:

  • on: indique la colonne avec laquelle la jointure sera effectuée. Cette option est utile si plusieurs colonnes sont communes.

    Par exemple:

    >>> df1 = pd.DataFrame({'id': [2, 1, 5], 'id2': ['a', 'b', 'c'], 'value1': [100, 165, 628]}); 
>>> print(df1)
   id id2  value1
0   2   a     100
1   1   b     165
2   5   c     628

>>> df2 = pd.DataFrame({'id': [1, 2, 8, 10], 'id2': ['c', 'e', 'd', 'a'], 'value2': [92, 27, 87, 43]});
>>> print(df2)
   id id2  value2
0   1   c      92
1   2   e      27
2   8   d      87
3  10   a      43

>>> print(df1.merge(df2, on='id2'))
   id_x id2  value1  id_y  value2
0     2   a     100    10      43
1     5   c     628     1      92
  • left_on et right_on: ces arguments permettent d’indiquer les colonnes sur lesquelles la jointure doit être effectuée respectivement pour le 1er (avant merge()) ou le 2e dataframe (fourni en argument de merge()).

    Par exemple, si on considère ces dataframes n’ayant pas de colonnes communes:

    >>> df1 = pd.DataFrame({'id_1': [2, 1, 5], 'value1': [100, 165, 628]}); 
>>> print(df1)
   id_1  value1
0     2     100
1     1     165
2     5     628

>>> df2 = pd.DataFrame({'id_2': [1, 2, 8, 10], 'value2': [92, 27, 87, 43]});
>>> print(df2)
   id_2  value2
0     1      92
1     2      27
2     8      87
3    10      43

    Si on effectue la jointure sur les colonnes id_1 et id_2:

    >>> print(df1.merge(df2, left_on='id_1', right_on='id_2'))
   id_1  value1  id_2  value2
0     2     100     2      27
1     1     165     1      92
  • left_index et right_index: ces arguments permettent d’effectuer une jointure sur les index plutôt que sur les colonnes. La jointure est effectuée pour le 1er dataframe (avant merge()) avec left_index et pour le 2e dataframe (fourni en argument de merge()) avec right_index.
  • how: cet argument permet d’imiter le comportement d’une jointure ouverte “outer join”, “left outer join” ou “right outer join”. Par défaut, la valeur est 'inner' pour jointure fermée. Les autres valeurs possibles:
    • 'outer' pour une jointure ouverte. Les entrées ayant des colonnes ou des index communs entre les 2 dataframes sont retournées. A ces résultats se rajoutent aussi les entrées qui ne sont pas communes entre les 2 dataframes.
    • 'left' pour une jointure ouverte par la gauche. Les entrées ayant des colonnes ou des index communs entre les 2 dataframes sont retournées. A ces résultats se rajoutent les entrées du 1er dataframe qui ne sont pas communs avec le 2e dataframe.
    • 'right' pour une jointure ouverte par la droite. Les entrées ayant des colonnes ou des index communs entre les 2 dataframes sont retournées. A ces résultats se rajoutent les entrées du 2e dataframe qui ne sont pas communs avec le 1er dataframe.
    • 'cross' pour effectuer un produit cartésien sur les entrées ayant des colonnes ou des index communs entre les 2 dataframes.
  • indicator: permet de rajouter une colonne nommée _merge permettant d’indiquer d’où provient l’entrée.

    Par exemple, si on considère les dataframes et la jointure suivants:

    >>> df1 = pd.DataFrame({'id': [2, 1, 5], 'value1': [100, 165, 628]}); 
>>> df2 = pd.DataFrame({'id': [1, 2, 8, 10], 'value2': [92, 27, 87, 43]});
>>> print(df1.merge(df2, how='outer', indicator=True))
   id  value1  value2      _merge
0   2   100.0    27.0        both
1   1   165.0    92.0        both
2   5   628.0     NaN   left_only
3   8     NaN    87.0  right_only
4  10     NaN    43.0  right_only

Concaténation

On peut effectuer des concaténations de dataframes ou de séries avec la fonction pd.concat([<dataframes ou series>]).

Par exemple, si on considère les dataframes suivants:

>>> df1 = pd.DataFrame([[1, 2, 3], [10, 20, 30]])
>>> df2 = pd.DataFrame([[11, 21, 31], [100, 200, 300]]) 
>>> print(pd.concat([df1, df2]))
     0    1    2
0    1    2    3
1   10   20   30
0   11   21   31
1  100  200  300

On peut remarquer que les colonnes sont les mêmes entre les 2 dataframes (colonnes implicites). Les index sont réutilisés.
Dans le cas où des colonnes ne sont pas communes, les valeurs sont complétées avec des NaN:

>>> df1 = pd.DataFrame([[1, 2, 3], [10, 20, 30]], columns=['a', 'b', 'c'])
>>> df2 = pd.DataFrame([[11, 21, 31], [100, 200, 300]], columns=['a', 'b', 'd'])
>>> print(pd.concat([df1, df2]))
     a    b     c      d
0    1    2   3.0    NaN
1   10   20  30.0    NaN
0   11   21   NaN   31.0
1  100  200   NaN  300.0

On peut concaténer une série à un dataframe:

>>> s = pd.Series([100, 200])
>>> print(pd.concat([df1, s], axis=1))
    0   1   2    0
0   1   2   3  100
1  10  20  30  200

On peut utiliser les arguments suivants pour modifier le comportement. Pour la suite, on définit les dataframes suivants:

>>> df1 = pd.DataFrame([[1, 2, 3], [10, 20, 30]])
>>> print(df1)
    0   1   2
0   1   2   3
1  10  20  30

>>> df2 = pd.DataFrame([[11, 21, 31], [100, 200, 300]])
>>> print(df2)
     0    1    2
0   11   21   31
1  100  200  300
  • ignore_index: permet d’ignorer les index d’origine des dataframes pour utiliser des index implicites.
    Si on considère les dataframes suivants:

    >>> print(pd.concat([df1, df2], ignore_index=True))
     0    1    2
0    1    2    3
1   10   20   30
2   11   21   31
3  100  200  300
  • axis: permet d’indiquer l’axe sur lequel la concaténation est effectuée: 0 pour index (valeur par défaut) et 1 pour colonne.

    Par exemple:

    >>> print(pd.concat([df1, df2], axis=1))
    0   1   2    0    1    2
0   1   2   3   11   21   31
1  10  20  30  100  200  300

    Les labels de colonnes sont maintenus. On peut utiliser ignore_index pour recréer des labels de colonnes implicites:

    >>> print(pd.concat([df1, df2], axis=1, ignore_index=True))
    0   1   2    3    4    5
0   1   2   3   11   21   31
1  10  20  30  100  200  300
  • keys: permet de rajouter un niveau dans les index du dataframe de sortie correspondant permettant d’indiquer le dataframe de départ. 
    >>> print(pd.concat([df1, df2], keys=['a', 'b']))
       0    1    2
a 0    1    2    3
  1   10   20   30
b 0   11   21   31
  1  100  200  300
  • join: permet d’indiquer le comportement lorsque les colonnes ou les index ne sont pas communs. Par défaut, la valeur est 'outer' pour indiquer les index ou les colonnes (suivant le sens de la concaténation) sont ajoutés dans le dataframe en sortie même s’ils ne sont pas communs.
    Si la valeur est 'inner' alors seuls les colonnes ou index communs seront pris en compte dans le dataframe en sortie.

    Par exemple, si on considère les dataframes suivants:

    >>> df3 = pd.DataFrame([[1, 2, 3], [10, 20, 30]], columns=['a', 'b', 'c'])
>>> print(df3)
    a   b   c
0   1   2   3
1  10  20  30

>>> df4 = pd.DataFrame([[11, 21, 31], [100, 200, 300]], columns=['a', 'b', 'd'])
>>> print(df4)
     a    b    d
0   11   21   31
1  100  200  300

    On peut voir la différence de comportement avec l’option join='inner':

    >>> print(pd.concat([df3, df4]))
     a    b     c      d
0    1    2   3.0    NaN
1   10   20  30.0    NaN
0   11   21   NaN   31.0
1  100  200   NaN  300.0


>>> print(pd.concat([df3, df4], join='inner'))
     a    b
0    1    2
1   10   20
0   11   21
1  100  200
Références

Séries Pandas

Cet article fait partie d’une série d’articles sur la syntaxe de base Python.

Une série pandas est une liste mutable d’objets dont les index peuvent être personnalisés. Le type des objets n’est pas forcément le même.

Sommaire

Initialisation
Indiquer explicitement le type des valeurs (argument dtype)
Initialiser sans effectuer de copies (argument copy)
Indiquer explicitement des index (argument index)

Accéder à une valeur à partir de l’index

Sous-série et slicing

Changement de type

Tester l’existence d’un index et d’une valeur
Tester l’existence d’un index
Tester l’existence d’une valeur

Itération sur les éléments de la structure

Opérations sur les séries pandas
Si les tailles des séries ne sont pas les mêmes
Si les index ne sont pas les mêmes

Fonctions particulières
Quelques fonctions utiles
<série>.str

Les séries pandas permettent de stocker tout type d’objets. L’intérêt de cette structure est l’utilisation d’index personnalisables permettant un accès performant aux objets. Les séries pandas ne permettent de stocker des objets que suivant une dimension. Pour stocker suivant 2 dimensions, il faut utiliser des dataframes.

Pandas peut être importé de cette façon pour utiliser les objets dans la bibliothèque:

import pandas as pd

Les séries pandas sont mutables c’est-à-dire qu’on peut modifier la valeur des éléments après instanciation.

Initialisation

On peut initialiser une série pandas à partir d’un tableau Python ou d’un tableau numpy.

Par exemple, à partir d’un tableau Python:

>>> a = pd.Series([1, 4, 5, 8])
>>> a
0    1
1    4
2    5
3    8
dtype: int64

On peut voir les valeurs ainsi que les index correspondant. Comme les index n’ont pas été précisés à l’initialisation, ce sont des index par défaut qui sont utilisés.

Pour initialiser une série pandas à partir d’un tableau numpy:

>>> a = np.array([1, 4, 5, 8])
>>> b = pd.Series(a)

Sans précision sur le type des éléments, pandas déduit le type des objets dans le cas où les objets ont le même type et sont de type float, int et bool sinon c’est le type object qui sera affecté: 

>>> a = np.array(['1', '4', '5', '8'])
>>> a
0    1
1    4
2    5
3    8
dtype: object

De même si les types des éléments sont différents alors le type affecté sera object.

Indiquer explicitement le type des valeurs (argument dtype)

Pandas reconnait les types numpy donc la même syntaxe que numpy peut être utilisée, par exemple:

>>> a = pd.Series([1, 4, 5, 8], dtype='i8')
>>> a
0    1
1    4
2    5
3    8
dtype: int64

La syntaxe plus haut est équivalente à:

>>> a = pd.Series([1, 4, 5, 8], dtype=np.int8)

A condition d’avoir importé la bibliothèque numpy avec:

import numpy as np

Initialiser sans effectuer de copies (argument copy)

Par défaut, quand une série pandas est initialisée à partir d’un tableau Python ou numpy, une copie des éléments est effectuée. Il est possible d’effectuer une initialisation de la série en utilisant des références vers les objets de la structure d’origine avec l’argument copy:

>>> a = np.array([1, 4, 5, 8])
>>> b = pd.Series(a, copy=False)
>>> a
array([1, 4, 5, 8])
>>> b[2]=1000
>>> a
array([   1,    4, 1000,    8])

L’initialisation de la série pandas étant faite avec des références, si on modifie une valeur dans la série alors les éléments dans la structure d’origine sont aussi modifiés.

Indiquer explicitement des index (argument index)

Par défaut, les index des éléments sont des entiers à partir de 0. Avec l’argument index, on peut explicitement préciser des index. Le type indiqué de l’objet doit être un tableau de même taille que la liste des valeurs:

>>> i = range(4, 8)
>>> list(i)
[4, 5, 6, 7]
>>> a = pd.Series([1, 4, 5, 8], index=i)
>>> a
4    1
5    4
6    5
7    8
dtype: int64

Pour créer plus directement une série:

>>> a = pd.Series([1, 4, 5, 8], range(4, 8))

Si la série contient la même valeur:

>>> a = pd.Series(5, range(4))
>>> a
0    5
1    5
2    5
3    5
dtype: int64

On peut affecter un index particulier après initialisation avec la propriété <série>.index. Il faut que la taille du tableau de l’index soit la même que celle de la série.

Par exemple:

>>> a = pd.Series([1, 4, 5, 8])
>>> a.index = ['a', 'b', 'c', 'd']
>>> a
a    1
b    4
c    5
d    8
dtype: int64

Accéder à une valeur à partir de l’index

Pour atteindre une valeur particulière, il suffit d’utiliser l’index:

>>> a = pd.Series([1, 4, 5, 8])
>>> a[2]
5

Si l’index n’existe pas, une exception est levée:

>>> a[5]
KeyError: 5

Si on considère la série suivante:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> a
a    1
b    4
c    5
d    8
dtype: int64

Il existe d’autres méthodes pour obtenir une valeur dans une série:

  • <série>.at[<index>]: par exemple 
    >>> a.at['c']
5

    Une exception est levée si l’index n’existe pas.

  • <série>.loc[<index>]: 
    >>> a.loc['c']
5

    Une exception est levée si l’index n’existe pas.

  • <série>.get(<index>): 
    >>> a.get('c')
5

    Si l’index n’existe pas, None est renvoyé.

Ces 3 syntaxes sont équivalentes.

Même si un index personnalisé est utilisé (différent d’un entier à partir de 0), on peut accéder aux valeurs en utilisant l’index par défaut avec les syntaxes:

  • <série>[<index numérique>]: 
    >>> a[1]
4

    Une exception est levée si l’index n’existe pas.

  • <série>.iat[<index numérique>]: 
    >>> a.iat[1]
4

    Une exception est levée si l’index n’existe pas.

  • <série>.iloc[<index numérique>]: 
    >>> a.iat[1]
4

    Une exception est levée si l’index n’existe pas.

  • <série>.get(<index numérique>): 
    >>> a.get(1)
4

    Si l’index n’existe pas, None est renvoyé.

Les syntaxes <série>[<index numérique>] et <série>.get(<index numérique>) sont sources d’ambiguïtés car:

  • Si l’index existe alors elles renvoient la valeur correspondant à l’index sinon
  • Si l’index n’existe pas, elles renvoient la valeur correspondant à l’index numérique.

Si on utilise ces syntaxes, il faut donc s’assurer du type d’index qu’on manipule.

Les autres syntaxes ne sont pas concernées par ces problèmes d’ambiguïté.

Par exemple, si on considère les séries suivantes:

>>> i1 = list(range(3, -1, -1))
>>> a = pd.Series([1, 4, 5, 8], index=i1)
>>> a
3    1
2    4
1    5
0    8
dtype: int64
>>> b = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> b
a    1
b    4
c    5
d    8
dtype: int64

>>> a[0]
8

0 existe en tant qu’index, la valeur renvoyée est la dernière valeur de la série. 

>>> b[0]
1

0 n’existe pas en tant qu’index donc la valeur renvoyée correspond à l’index numérique 0.

Sous-série et slicing

On peut extraire des sous-séries à partir d’une série existante en indiquant explicitement les index numériques à extraire ou en utilisant la syntaxe de slicing.

Par exemple, si on considère la série suivante:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> a
a    1
b    4
c    5
d    8
dtype: int64

Pour extraire une sous-série en indiquant explicitement les index numériques à extraire:

>>> b = a[['b', 'd', 'c']]
>>> b 
b    4
d    8
c    5
dtype: int64

On peut utiliser les règles de slicing habituelles en utilisant les index numériques, par exemple:

>>> c =  a[1:3]
>>> c
b    4
c    5
dtype: int64

Enfin, iloc[] peut être utilisé pour extraire la sous-série en utilisant les index numériques. iloc[] évite les ambiguïtés décrites plus haut puisqu’il ne traite que les index numériques:

>>> a.iloc[1:3]
b    4
c    5
dtype: int64
>>> a.iloc[[1,3]]
b    4
d    8
dtype: int64

Suivant la façon dont la sous-série est extraite, il peut s’agir d’une copie ou d’une référence vers la série d’origine. Dans le cas de références, les modifications dans la sous-série entraînent des modifications dans la série d’origine:

  • Si on indique explicitement les index de la série, la sous-série est une copie.
  • Si on utilise la syntaxe de slicing sur les index numériques, la sous-série contient des références.

Par exemple, si on considère la série suivante:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> a
a    1
b    4
c    5
d    8
dtype: int64

Si on extrait une sous-série en indiquant explicitement les index de la série d’origine:

>>> b = a[['a', 'b']]
>>> b[0] = 1000
>>> b
a    1000
b       4
dtype: int64

>>> a
a    1
b    4
c    5
d    8
dtype: int64

La série d’origine n’est pas modifiée.

Si on effectue un slicing avec les index numériques:

>>> c = a[1:3] 
>>> c[0] = 1000
>>> c
b    1000
c       5
dtype: int64
>>> a
a       1
b    1000
c       5
d       8
dtype: int64

La série d’origine est modifiée.

Pour éviter de modifier la structure d’origine, on peut effectuer une copie avec copy(): 

c = a[1:3].copy()

Changement de type

Il est possible de changer le type des éléments d’une série en appliquant la fonction <série>.astype(<nouveau type>). La série résultante contient les mêmes index que la série d’origine. Pour indiquer le type, on peut utiliser la même syntaxe qu’à l’initialisation.

Par exemple:

>>> a = pd.Series(['5', '4', '3', '2', '1']) 
>>> a.astype(float)
0    5.0
1    4.0
2    3.0
3    2.0
4    1.0
dtype: float64

Par défaut, si le changement de type n’est pas possible, une erreur est renvoyée:

>>> a = pd.Series(['5', '4', '3', np.NaN, 'Oups', '1'])
>>> a.astype(float)
ValueError: could not convert string to float: 'Oups'

Cette erreur peut être ignorée en faisant:

>>> a.astype(float, errors='ignore')
0       5
1       4
2       3
3     NaN
4    Oups
5       1
dtype: object

En cas d’erreur, l’objet original est renvoyé.

Tester l’existence d’un index et d’une valeur

Tester l’existence d’un index

L’opérateur in peut être utilisé pour tester l’existence d’un index dans une série pandas, par exemple:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> 'b' in a
True
>>> 'e' in a 
False

Si on utilise in directement sur une série, on teste l’existence d’un index dans la série et non l’appartenance de la valeur aux valeurs de la série.

Tester l’existence d’une valeur

Pour tester l’appartenance d’une valeur aux valeurs de la série, il faut utiliser in avec <série>.values:

>>> 4 in a.values
True
>>> 7 in a.values
False

Itération sur les éléments de la structure

On peut itérer directement parmi les valeurs d’une série avec une boucle “for“:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> for item in a:
    print(item)
1
4
5
8

La fonction <série>.iteritems() peut être utilisée pour obtenir un itérable contenant pour chaque élément son index et sa valeur, par exemple:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> for item in a.iteritems():
    print('Index: %s - valeur: %d' % item)
Index: a - valeur: 1
Index: b - valeur: 4
Index: c - valeur: 5
Index: d - valeur: 8

Opérations sur les séries pandas

Des opérations mathématiques peuvent être appliquées directement sur des séries pandas.

Par exemple, si on considère la série:

>>> a = pd.Series([1, 4, 5, 8])
>>> a
0    1
1    4
2    5
3    8
dtype: int64
>>> 2*a
0     2
1     8
2    10
3    16
dtype: int64

On peut aussi appliquer des opérations entre 2 séries pandas mais contrairement aux tableaux numpy, il n’est pas obligatoire que les 2 séries soient de même dimension. Toutefois, il faut que les types des éléments des séries permettent l’application de l’opération.

Par exemple si on considère les séries suivantes:

>>> a = pd.Series([1, 4, 5, 8])
>>> b = pd.Series([5, 4, 3, 2])
>>> a+b
0     6
1     8
2     8
3    10
dtype: int64

L’opération est appliquée sur tous les éléments des séries en préservant le type de ces derniers.

Si le type n’est pas le même, il peut être modifié pour rendre l’opération possible, par exemple:

>>> a = pd.Series([1, 4, 5, 8])
>>> b = pd.Series([5.0, 4.0, 3.0, 2.0])
>>> a+b
0    5.0
1    4.0
2    3.0
3    2.0
dtype: float64

a est une série contenant des entiers et b contient des flottants, en appliquant l’opération les éléments de a sont transformés en flottants pour rendre l’opération possible. Le résultat est une série de flottants.

La modification du type n’est pas tout le temps possible, par exemple si on considère une série de chaînes de caractères:

>>> c = pd.Series(['5', '4', '3', '2'])
>>> a+c
TypeError: unsupported operand type(s) for +: 'int' and 'str'

En revanche, si les éléments de 2 séries sont des chaînes de caractères alors l’opération est possible, le résultat est la concaténation des chaînes:

>>> d = pd.Series(['1', '4', '5', '8'])
>>> c+d
0    51
1    44
2    35
3    28
dtype: object

Quand on applique l’opération *, tous les éléments des séries sont multipliés:

>>> a = pd.Series([1, 4, 5, 8])
>>> b = pd.Series([5, 4, 3, 2])
>>> a*b
0     5
1    16
2    15
3    16
dtype: int64

Si les tailles des séries ne sont pas les mêmes

Si les tailles des séries ne sont pas identiques, l’opération est quand même appliquée toutefois quand il n’existe pas d’éléments dans une série permettant l’opération, la valeur résultante est NaN:

>>> a = pd.Series([1, 4, 5, 8])
>>> b = pd.Series([5, 4, 3, 2, 1])
>>> a+b
0     6.0
1     8.0
2     8.0
3    10.0
4     NaN
dtype: float64

Dans ce cas, la 5e valeur est NaN et les valeurs sont transformées en flottants à cause de la valeur manquante dans a.

Si les index ne sont pas les mêmes

Dans le cas où les index des séries ne sont pas les mêmes:

  • Pour les index communs: l’opération est appliquée.
  • Pour les index qui ne sont pas communs: le résultat de l’opération est NaN.

Par exemple:

>>> a = pd.Series([1, 4, 5, 8], ['a', 'b', 'c', 'd'])
>>> b = pd.Series([5, 4, 3, 2], ['a', 'e', 'c', 'f'])
>>> a+b
a    6.0
b    NaN
c    8.0
d    NaN
e    NaN
f    NaN
dtype: float64

La fonction dropna() peut être utilisée pour supprimer les valeurs NaN:

>>> c = a+b
>>> c.dropna()
a    6.0
c    8.0
dtype: float64

Pour résumer, on peut appliquer les opérations comme:

  • +, -, / ou *. Ces opérations sont appliquées sur les éléments des tableaux avec le même index. Pour les éléments dont les index ne sont pas les mêmes, le résultat est NaN. On peut s’aider de dropna() pour supprimer les éléments dont la valeur est NaN.
  • Les opérations booléennes entre séries pandas peuvent être effectuées en utilisant:
    • & pour “and“,
    • | pour “ou“,
    • ~ pour “not“,
    • ^ pour le “ou exclusif“.
  • Appliquer des opérateurs de comparaison comme ==, <, >, <=, >= et !=.

Fonctions particulières

Quelques fonctions utiles

On peut appliquer les fonctions mathématiques numpy à une série pandas. Le résultat est une série.

Par exemple si on importe numpy avec import numpy as np:

>>> a = pd.Series([1, 4, 5, 8])
>>> np.log(a)
0    0.000000
1    1.386294
2    1.609438
3    2.079442
dtype: float64

De la même façon, les fonctions suivants peuvent être appliquées:

  • np.add(a, b); np.subtract(a, b); np.divide(a, b) ou np.multiply(a, b) pour respectivement ajouter, soustraire, diviser ou multiplier les éléments de séries pandas.
  • np.sum(a) ou np.prod(a) pour respectivement ajouter ou multiplier tous les éléments d’une série.
  • np.floor(a), np.ceil(a) ou np.trunc(a) pour effectuer des arrondis ou troncatures sur les éléments d’une série.
  • np.amin(a), np.amax(a) pour obtenir le minimum ou maximum parmi les éléments de la série.
  • np.argmin(a), np.argmax(a) pour obtenir l’index du minimum ou du maximum des éléments de la série.
  • np.mean() pour obtenir la moyenne des éléments de la série.

Une liste plus exhaustive des opérations numpy possibles peut être retrouvée sur: numpy.org/doc/stable/reference/routines.math.html.

D’autres fonctions permettent d’éviter d’itérer sur les éléments de la série:

  • <série>.index permet d’obtenir un itérable (de type RangeIndex ou Index) contenant les index de la série.
  • <série>.values pour obtenir un tableau numpy contenant les valeurs de la série.
  • <série>.unique pour obtenir un tableau numpy contenant les valeurs uniques de la série.
  • <série>.value_counts() permet d’obtenir une série avec les mêmes index que la série d’origine et le nombre d’occurence pour chaque valeur.
  • <série>.isna() ou <série>.isnull() renvoie une série avec les mêmes index que la série d’origine et des booléens pour indiquer si les valeurs correspondantes sont NaN.
  • <série>.inotna() ou <série>.notnull() renvoie une série avec les mêmes index que la série d’origine et des booléens pour indiquer si les valeurs correspondantes ne sont pas égales à NaN.
  • pd.isnull(<série>) renvoie une série dont les index sont les mêmes que la série d’origine et dont les valeurs sont True si les valeurs correspondantes sont égales à NaN ou None.
  • pd.notnull(<série>) renvoie une série dont les index sont les mêmes que la série d’origine et dont les valeurs sont True si les valeurs correspondantes ne sont pas égales à NaN ou None.
  • <série>.min(), <série>.max(), <série>.mean(), <série>.median() pour respectivement renvoyer le minimum, maximum, la moyenne et la moyenne médiane des valeurs de la série.
  • <série>.all() indique si toutes les valeurs de la série sont égales à True au sens Truthy/Falsy (voir Truthy vs Falsy).
  • <série>.any() indique si au moins une valeur de la série est égale à True au sens Truthy/Falsy.
  • <série>.sort_index() renvoie une série avec les index ordonnés.
  • <série>.sort_values() renvoie une série avec les valeurs ordonnées.
  • <série>.apply(<fonction>) renvoie une série où la fonction est exécutée pour toutes les valeurs.

    Par exemple avec une lambda:

    >>> a = pd.Series([1, 4, 5, 8])
>>> a.apply(lambda x: 3 * x)
a     3
b    12
c    15
d    24
dtype: int64
  • <série>.to_frame() renvoie un dataframe avec une seule colonne contenant les valeurs de la série en ligne.

<série>.str

L’objet <série>.str permet d’appliquer des traitements sur les éléments d’une série lorsque ce sont des chaînes de caractères.

Par exemple:

  • <série>.str.startswith(<chaine de caractères>): renvoie une série dont les index sont les mêmes que la série d’origine et dont les valeurs contiennent True si la chaine de caractères correspondante commence par la chaîne donnée.
  • <série>.str.len() renvoie une série dont les index sont les mêmes que la série d’origine et dont les valeurs sont les longueurs des chaînes de caractères correspondantes.
  • <série>.str.match(<regex>) renvoie une série dont les valeurs sont True si la valeur correspondante dans la série d’origine satisfait la regex donnée.
  • <série>.str.contains(<regex>) renvoie une série dont les valeurs sont True si la valeur correspondante dans la série d’origine contient une sous-chaine satisfaisant la regex donnée.
  • <série>.str.contains(<chaîne de caractères>, regex=False) renvoie une série dont les valeurs sont True si la valeur correspondante dans la série d’origine contient une sous-chaine donnée.
  • <série>.str.find(<chaine>) renvoie une série dont les valeurs sont les index dans la chaîne de caractère de la 1ère occurence de la chaine donnée. Si la chaîne ne contient pas la chaine donnée, la valeur retournée est -1.
  • <série>.str.get(<index>) renvoie une série dont les valeurs contiennent le caractère correspondant à l’index donnée dans la chaîne de caractères correspondante.
  • <série>.str.slice(<index début>, <nombre de caractères>) renvoie une série dont les valeurs sont des sous-chaînes de la chaine correspondante dans la série d’origine.
  • <série>.str[<argument slicing>] renvoie une série dont les valeurs proviennent d’un slicing appliquée sur la chaîne correspondante dans la série d’origine.
  • <série>.str.count(<regex>) renvoie une série dont les valeurs contiennent le nombre d’ocurrences de la regex dans la chaîne correspondante dans la série d’origine.
  • <série>.str.replace(<regex>, <chaine de remplacement>) renvoie une série dont les valeurs contiennent un remplacement des chaines d’origine suivant la regex.

Tableaux Numpy

Cet article fait partie d’une série d’articles sur la syntaxe de base Python.

On se propose de passer en revue les fonctionnalités principales de quelques structures permettant des stocker des éléments en Python. On commence pour les tableaux numpy, d’autres articles permettront d’étudier les séries et les dataframes pandas.

Sommaire

Initialisation
Préciser le type des éléments
Créer un tableau à plusieurs dimensions

Construction avec des fonctions particulières
arange()
linspace()
reshape()
np.zeros(), np.eyes() et np.ones()
np.diag()
np.random.rand()

Fonctionnement général des index
Slicing
Dans le cas multidimensionnel

Fonctions et propriétés particulières
dtype
np.append()
np.insert()
np.concatenate()
copy()
np.take()
np.put()

Itération sur les éléments de la structure
Itération directe
Itération avec np.nditer()
Itération avec np.ndenumerate()

Opérations sur les tableaux numpy

Par rapport aux listes basiques, les tableaux numpy imposent que tous les objets soient de même type. Cette condition sécurise davantage le contenu du tableau par rapport aux listes Python. Les tableaux numpy sont mutables et ordonnés.
Les tableaux numpy permettent de stocker tout type d’objets toutefois ils sont particulièrement adaptés pour les valeurs numériques. En effet, les tableaux numpy offrent une solution pour stocker des matrices de plusieurs dimensions et pour effectuer des opérations entre matrices.

On peut importer numpy de cette façon pour utiliser les objets dans la bibliothèque:

import numpy as np

Voir Import de modules pour plus de détails.

Initialisation

Classiquement, un tableau numpy s’initialise en utilisant une liste Python:

>>> a = np.array([1, 4, 5, 8])

Sans précision sur le type des éléments, numpy déduit le type des objets en sélectionnant un type le plus précis qui permet de prendre en compte toutes les valeurs. Une conversion implicite est effectuée pour que toutes les valeurs soient du même type.

Par exemple, le type des objets du tableau plus haut sera:

>>> a.dtype 
dtype('int64')

Si une valeur est de type float avec tous les éléments du tableau en float:

>>> a = np.array([1, 4, 5., 8])
>>> a.dtype
dtype('float64')

Si un élément est une chaine de caractères alors le type du tableau sera une chaine de caractères car c’est le type le plus précis qui permet de stocker toutes les valeurs. Les autres valeurs seront implicitement convertis:

>>> a = np.array([1, 4, 5., '8'])
>>> a.dtype
dtype('<U32')

>>> a
array(['1', '4', '5.0', '8'], dtype='<U32')

'<U32' correspond au type d’une chaîne de caractères:

  • < pour indiquer l’ordre des octets (< pour little endian et > pour big endian).
  • U pour signifier une chaîne de caractères Unicode.
  • 32 pour indiquer 32 octets.

Si on indique un type ne pouvant contenir les données, les données seront tronquées:

names = ['a1', 'b2', 'c3', 'd4', 'e5', 'f6', 'g7', 'h8', 'i9', 'j0']
np_array = np.array(names, 'U1')
array(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'], dtype='<U1')

Si les données ne peuvent pas être converties, il peut survenir une erreur:

names = ['a1', 'b2', 'c3', 'd4', 'e5', 'f6', 'g7', 'h8', 'i9', 'j0']
np_array = np.array(names, float)
ValueError could not convert string to float: 'a1'

Préciser le type des éléments

On peut explicitement préciser le type des éléments:

>>> a = np.array([1, 4, 5, 8], float)
>>> a
array([1., 4., 5., 8.])

Si une valeur n’est pas convertible implicitement alors une erreur est générée:

>>> a = np.array([1, 4, 5, 8, 'chaine'], float)
ValueError: could not convert string to float: 'chaine'

Les types possibles des éléments sont: numpy.org/doc/stable/reference/arrays.scalars.html.

Quelques types courants:

  • Nombre flottant: float ou np.float64
  • Nombre entier: int ou int64
  • Booléen: bool
  • Chaine de caractères: str

On peut utiliser les raccourcis suivants pour préciser les types:

  • '?': booléen
  • 'b': (signé) octet
  • 'B': octet non signé
  • 'i': (signé) entier
  • 'u': entier non signé
  • 'f': flottant
  • 'c': flottant complexe
  • 'm': timedelta
  • 'M': datetime
  • 'O': (Python) objects
  • 'U': chaîne de caractères unicode
  • 'V': Donnée brute (void)

Pour les types de nombre, on peut préciser le nombre d’octets occupé par l’objet, par exemple:

  • 'i4' désigne en entier sur 4 octets soit sur 32 bits.
  • 'i8' désigne en entier sur 8 octets soit sur 64 bits.

Pour plus de détails, voir numpy.org/doc/stable/reference/arrays.dtypes.html.

Créer un tableau à plusieurs dimensions

On peut initialiser un tableau numpy avec des tableaux à plusieurs dimensions, par exemple:

  • 1 dimension: 
    >>> oneDimArray=[1,2,3]
>>> a=np.array(oneDimArray)
>>> a.shape
(3, )
  • 2 dimensions: 
    >>> twoDimArray=[[1,2,3],[4,5,6],[7,8,9]]
>>> a=np.array(twoDimArray)
>>> a.shape
(3, 3)
  • 3 dimensions: 
    >>> threeDimArray=[
    [[1,2,3],[4,5,6],[7,8,9]],
    [[10,11,12],[13,14,15],[16,17,18]],
    [[19,20,21],[22,23,24],[25,26,27]]
]
>>> a=np.array(threeDimArray)
>>> a.shape
(3, 3, 3)

Il n’y a pas de limitation concernant le nombre de dimensions.

Construction avec des fonctions particulières

Quelques fonctions permettent de construire un tableau numpy avec des caractéristiques particulières.

arange()

La fonction arange() est l’équivalent de range() pour les listes Python. Cette fonction permet de créer un tableau:

  • np.arange(10) va créer un tableau de 10 éléments en commençant par 0. 
    >>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  • np.arange(5, 10) crée un tableau d’entiers de 5 à 10 (10 exclu): 
    >>> np.arange(5, 10) 
array([5, 6, 7, 8, 9])
  • np.arange(5, 10, 2) crée un tableau d’entiers de 5 à 10 par pas de 2 (10 est exclu): 
    >>> np.arange(5, 10, 2) 
array([5, 7, 9])
  • On peut préciser un type particulier: np.arange(5, 10, 2, dtype=np.float64) produit un tableau de flottants de 5 à 10 par pas de 2 (10 exclu): 
    >>> np.arange(5, 10, 2, dtype=np.float64) 
array([5., 7., 9.])

linspace()

Cette fonction a un comportement similaire à arange() à la différence qu’elle n’exclut pas le dernier élément.

Ainsi:

  • np.linspace(1, 10, 5) permet de créer un tableau de 5 flottants de 1 à 10 inclus: 
    >>> np.linspace(1, 10, 5)
array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ])
  • np.linspace(1, 10, 5, dtype=int) permet de créer un tableau de 5 entiers de 1 à 10 inclus: 
    >>> np.linspace(1, 10, 5, dtype=int)
array([ 1,  3,  5,  7, 10])

reshape()

reshape() permet de créer un tableau à partir d’un autre tableau en redimensionnant sa taille. La seule condition entre le tableau de départ et d’arrivée est d’avoir le même nombre d’éléments.

Par exemple, si on considère le tableau:

>>> a=np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.reshape(a, (2, 5)) 
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
np.reshape(a, (2, 5)) permet de créer un tableau de 2 lignes et 5 colonnes.

De même:

>>> a=np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
>>> np.reshape(a, 9)
array([0, 1, 2, 3, 4, 5, 6, 7, 8])

np.reshape(a, 9) va permettre de convertir de 3 lignes et 3 colonnes en une liste de 9 éléments.

np.zeros(), np.eyes() et np.ones()

Ces fonctions permettent de produire des matrices particulières:

  • np.zeros() crée un matrice ne contenant que des zéros sous la forme de flottants.
    • np.zeros(n) produit une matrice carrée de taille n contenant des zéros.
    • np.zeros((n, m)) produit une matrice de n lignes et m colonnes des zéros.
    • np.zeros((n, m), dtype=int) crée une matrice contenant des zéros sous forme d’entiers.
  • np.eyes() permet de créer une matrice avec 1 sur la diagonales. La syntaxe est similaire à celle de np.zeros().
  • np.ones() permer de créer une matrice avec des 1. La syntaxe est similaire à celle de np.zeros().

np.diag()

np.diag() permet de créer une matrice à partir d’un vecteur. Ce vecteur se trouve sur la diagonale de la matrice.

Par exemple:

>>> a=np.array([0, 1, 2, 3])
>>> np.diag(a)
array([[0, 0, 0, 0],
       [0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3]])

np.random.rand()

Cette fonction produit un tableau de flottants aléatoires:

  • np.random.rand(6) produit un tableau de 6 flottants.
  • np.random.rand(6, 9) produit un matrice de 6 lignes et 9 colonnes avec des flottants choisis aléatoirement.

Fonctionnement général des index

L’utilisation des index est classique et similaire aux listes Python. Les index commencent à 0.

Par exemple:

  • Pour un tableau à 1 dimension, a[1] permet d’accéder au 2e élément de a: 
    >>> a=np.array([1,2,3])
>>> a[1]
2
  • Pour un tableau à 2 dimensions, on utilise 2 coordonnées: 
    >>> a=np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> a[1, 0]
4

Slicing

La fonctionnalité de slicing valable pour les listes Python (voir list slicing) est aussi utilisable pour les tableaux numpy. Avec la syntaxe suivante, on peut extraire un tableau du tableau:

[<index de début>:<index de fin exclu>:<pas utilisé>]

Par exemple, si on considère le tableau suivant:

>>> a=np.array([1,2,3,4,5,6,7,8,9])
>>> a[2:4]
array([3, 4])

a[2:4] permet d’obtenir un tableau numpy à partir du 3e élément jusqu’au 5e élément (l’index commençant à 0).

En utilisant les index pour extraire des éléments d’un tableau numpy, on extrait une référence du tableau. Il n’y a pas de copie. Cela signifie que si on modifie un élément dans la référence, le tableau initial est aussi modifié.

Par exemple:

>>> b = a[2:4]
>>> b[0] = 100  # On modifie le 1er élément de b et donc le 3e élément de a
>>> a
array([  1,   2, 100,   4,   5,   6,   7,   8,   9])

Concernant les index, les règles sont similaires à celles des listes Python. Si on considère le tableau numpy suivant:

>>> a=np.array([1,2,3,4,5,6,7,8,9])

Alors:

  • [2:] permet de commencer à l’index 2 (3e élément) jusqu’au dernier: 
    >>> a[2:]
array([3, 4, 5, 6, 7, 8, 9])
  • [:3] permet de commencer du début jusqu’à l’index 2 (3e élément). L’index est exclu: 
    >>> [:3] 
array([1, 2, 3])
  • On peut utiliser des index négatifs: -1 signifie le 1er élément en partant de la fin de la liste. 
    >>> a[-3]
7
  • [:] désigne tous les éléments de la liste. 
    >>> a[:]
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Dans le cas des tableaux numpy [:] n’effectue pas une copie. Cette syntaxe permet d’extraire une référence vers le tableau d’origine:

>>> b = a[:]
>>> b[3] = 100
>>> a
array([  1,   2,   3, 100,   5,   6,   7,   8,   9])

Le tableau initial est modifié.

Dans le cas multidimensionnel

Dans le cas de tableaux à plusieurs dimensions, les index sont séparés par des virgules:

[<index dimension 1>, <index dimension 2>, <index dimension 3>, etc]

Ainsi si on considère le tableau suivant:

>>> a=np.array([
    [[1,2,3],[4,5,6],[7,8,9]],
    [[10,11,12],[13,14,15],[16,17,18]],
    [[19,20,21],[22,23,24],[25,26,27]]
])

On peut lire le tableau comme étant 3 tableaux imbriqués. Si on écrit a[1,1,1], on considère:

  • L’index 1 du 1er tableau contenant [[1,2,3],[4,5,6],[7,8,9]]; [[10,11,12],[13,14,15],[16,17,18]] et [[19,20,21],[22,23,24],[25,26,27]]. L’index 1 est [[10,11,12],[13,14,15],[16,17,18]].
  • L’index 1 du 2e tableau contenant [10,11,12],[13,14,15],[16,17,18]. L’index 1 est [13,14,15].
  • L’index 1 du 3e tableau contenant[13,14,15]. L’index 1 est 14.

Si on considère l’index a[1:,1,1], on applique la même logique que précédemment sur le 1er tableau. 1: correspond à tout après l’index 1 inclus soit: [[10,11,12],[13,14,15],[16,17,18]] et [[19,20,21],[22,23,24],[25,26,27]].

Le résultat est donc:

array([14, 23])

De même, l’index a[::2,1,1] correspond à lister les éléments du 1er tableau par pas de 2 soit le 1er et le 3e élément: [[1,2,3],[4,5,6],[7,8,9]] et [[19,20,21],[22,23,24],[25,26,27]].

On applique ensuite les index pour obtenir:

array([ 5, 23])

Fonctions et propriétés particulières

Quelques fonctions ou propriétés utiles.

dtype

Pour obtenir le type des éléments on peut utiliser dtype:

>>> a = np.array([1, 4, 5, 8])
>>> a.dtype
dtype('int64')

np.append()

Cette fonction permet de rajouter des valeurs à la fin d’un tableau. Le résultat est un nouveau tableau.

Par exemple:

>>> a=np.array([1, 2, 3, 4])
>>> np.append(a, [5, 6])
array([1, 2, 3, 4, 5, 6])

Quand on ne précise pas d’axe indiquant la dimension suivant laquelle l’ajout sera effectué, les données sont aplanies et sont utilisées suivant une seule dimension, par exemple:

>>> a=np.array([1, 2])
>>> np.append(a, [[4, 5, 6], [7, 8, 9]])
array([1, 2, 4, 5, 6, 7, 8, 9])

Si on précise l’argument axis, on peut préciser la dimension suivant laquelle on peut ajouter des éléments au tableau existant. En précisant l’axe, les dimensions initiales du tableau sont maintenues.

Par exemple: 

>>> a=np.array([[1, 2, 3], [4, 5, 6]])
>>> np.append(a, [[7, 8, 9]], axis=0)
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

[[1, 2, 3], [4, 5, 6]] et [[7, 8, 9]] peuvent être ajoutés car ils ont le même nombre de dimension. Ajouter [[1, 2, 3], [4, 5, 6]] et [7, 8, 9] ne fonctionnent pas car [7, 8, 9] a une dimension 1.

Suivant l’autre axe:

>>> a=np.array([[1, 2, 3], [4, 5, 6]])
>>> np.append(a, [[7, 8, 9], [10, 11, 12]], axis=1)
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])

np.insert()

np.insert() permet d’insérer des valeurs dans un tableau en précisant l’index à partir duquel on effectue l’ajout. Le résultat est un nouveau tableau.

Par exemple:

>>> a=np.array([1, 2, 3, 4])
>>> np.insert(a, 2, [5, 6])
array([1, 2, 5, 6, 3, 4])

Les éléments sont rajoutés à partir de l’index 2.

Quand on ne précise pas d’axe indiquant la dimension suivant laquelle l’ajout sera effectué, les données sont aplanies et sont utilisées suivant une seule dimension.

Si on précise l’argument axis, on peut préciser la dimension suivant laquelle on peut ajouter des éléments au tableau existant. En précisant l’axe, les dimensions initiales du tableau sont maintenues.

Par exemple: 

>>> a=np.array([[1, 2, 3], [4, 5, 6]])
>>> np.insert(a, 1, [7, 8, 9], axis=0)
array([[1, 2, 3],
       [7, 8, 9],
       [4, 5, 6]])

Suivant l’autre axe:

>>> a=np.array([[1, 2, 3], [4, 5, 6]])
>>> np.insert(a, 1, [7, 8], axis=1)
array([[1, 7, 2, 3],
       [4, 8, 5, 6]])

Si on utilise des scalaires, le comportement est différent. Le scalaire est rajouté en tant que vecteur suivant l’axe considéré.

Par exemple:

>>> a=np.array([[1, 2, 3], [4, 5, 6]])
>>> np.insert(a, 1, 7, axis=0)
array([[1, 2, 3],
       [7, 7, 7],
       [4, 5, 6]])
>>> np.insert(a, 1, 7, axis=1)
array([[1, 7, 2, 3],
       [4, 7, 5, 6]])

np.concatenate()

Cette fonction permet de concaténer des tableaux, par exemple:

>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> b = np.array([[7, 8, 9]])
>>> c = np.array([[10, 11, 12]])
>>> np.concatenate((a, b, c))
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])

Par défaut, l’argument axis=0. Si on indique axis=None alors les données sont aplanies:

>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> b = np.array([7, 8, 9])
>>> c = np.array([10, 11, 12])
>>> np.concatenate((a, b, c), axis=None)
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

Suivant l’autre axe:

>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> b = np.array([[7], [8]])
>>> np.concatenate((a, b), axis=1)
array([[1, 2, 3, 7],
       [4, 5, 6, 8]])

copy()

On l’a vu précédemment, la plupart des opérations sur les tableaux numpy produisent une référence sur le tableau d’origine. Pour effectuer une copie d’un tableau, on peut utiliser copy(). 2 syntaxes existent: <tableau numpy>.copy() ou np.copy(<tableau numpy>):

>>> a=np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b=a.copy()
>>> b
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

On peut remplacer b=a.copy() par b=np.copy(a).

np.take()

np.take() permet d’extraire une matrice à partir d’un autre matrice en désignant les lignes ou les colonnes par leur index.

Par exemple si on considère la matrice:

>>> a = np.array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

On peut produire une nouvelle en considérant les lignes avec les index 0 et 2:

>>> a.take([0,2],axis=0)
array([[1, 2, 3],
       [7, 8, 9]])

En utilisant axis=1, on peut faire la sélection suivant les colonnes plutôt que les lignes:

>>> a.take([0,2],axis=1)
array([[1, 3],
       [4, 6],
       [7, 9]])

np.put()

np.put() permet de remplacer des éléments d’un tableau. Pour indiquer les index des éléments à remplacer, il faut considérer les index comme si les données étaient aplanies. np.put() effectue le remplacement directement sur le tableau fourni en paramètre.

Par exemple:

>>> a = np.array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> np.put(a, [2, 0, 7], [100, 101, 102])
>>> a
array([[101,   2, 100],
       [  4,   5,   6],
       [  7, 102,   9]])

Le remplacement a été effectué au index 2, 0 et 7 comme si le tableau d’origine était disposé à plat:

[1, 2, 3, 4, 5, 6, 7, 8, 9] => [101, 2, 100, 4, 5, 6, 7, 102, 9]

Itération sur les éléments de la structure

Pour parcourir un tableau numpy, plusieurs solutions sont possibles avec l’opérateur for.

Itération directe

On peut parcourir directement toutes les dimensions d’un tableau numpy en utilisant plusieurs boucles for imbriquées.

Par exemple, si considère la tableau suivant comportant 2 dimensions:

>>> a = np.array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Si on itère avec un boucle for:

for x in a:
    print(x)

[1 2 3]
[4 5 6]
[7 8 9]

On itère suivant la 1ère dimension. Pour itérer suivant la 2e dimension, il faut utiliser une 2e boucle for imbriquée:

for x in a:
    for y in x:
        print(y) 

1
2
3
4
5
6
7
8
9

Le gros inconvénient de cette méthode est qu’il faut connaître les dimensions du tableau pour savoir combien de boucles for imbriquées sont nécessaires pour parcourir toutes les valeurs.

Itération avec np.nditer()

L’intéret de np.nditer() est qu’il va permettre de parcourir tous les éléments du tableau quelque soit le nombre de dimension. Le parcours se fait en considérant les index à plat du tableau.

Par exemple si on considère le tableau:

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Disposé à plat:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Si on parcourt le tableau avec np.nditer():

for x in np.nditer(a):
    print(x)

1
2
3
4
5
6
7
8
9

np.nditer() possède de nombreuses options:

  • Pour parcourir le tableau dans le sens des colonnes plutôt que dans le sens des lignes avec l’option order='F', par exemple: 
    for x in np.nditer(a, order='F'):
     print(x)

    1
4
7
2
5
8
3
6
9
  • Permettre la modification du tableau lors de son parcours avec l’option op_flags=['readwrite']: 
    with np.nditer(a, op_flags=['readwrite']) as it:
    for x in it:
        x[...] = 2 * x

    >>> a
array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])
  • Pour avoir les index des valeurs parcourues, il faut utiliser l’option flags=['c_index'] pour effectuer le parcourt dans le sens des lignes et flags=['f_index'] pour parcourir dans le sens des colonnes.

    Par exemple:

    it = np.nditer(a, flags=['c_index'])
for x in it:
    print(it.index, x)

    0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18

    Dans le sens des colonnes:

    it = np.nditer(a, flags=['f_index'])
for x in it:
    print(it.index, x)

    0 2
3 4
6 6
1 8
4 10
7 12
2 14
5 16
8 18

Itération avec np.ndenumerate()

np.ndenumerate() permet de fournir un index sous la forme d’un tuple.

Par exemple si on considère le tableau:

a = np.array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

On peut le parcourir de cette façon et obtenir les index des valeurs:

for index, x in np.ndenumerate(a):
    print(index, x)

(0, 0) 1
(0, 1) 2
(0, 2) 3
(1, 0) 4
(1, 1) 5
(1, 2) 6
(2, 0) 7
(2, 1) 8
(2, 2) 9

La variable index est un tuple. On peut utiliser les différentes valeurs avec index[0] et index[1] dans le cas d’un tableau à 2 dimensions:

for index, x in np.ndenumerate(a):
    print(index[0], index[1], x)

Opérations sur les tableaux numpy

Il est possible d’appliquer facilement des opérations mathématiques sur les tableaux numpy.

Par exemple, si on considère le tableau:

>>> a = np.array([1, 2, 3, 4, 5, 6])
>>> 2*a
array([ 2,  4,  6,  8, 10, 12])

Ce type d’opération est applicable sur les tableaux quelque soit leur dimension:

>>> a = np.array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> 2*a
array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])

On peut appliquer d’autres opérations comme:

  • +, -, / ou * à condition que les tableaux soient de même taille. Ces opérations sont appliquées sur les éléments des tableaux avec le même index.
  • Opérations booléennes comme and, or et le “ou exclusif” avec np.logical_xor(a,b).
  • Appliquer des opérateurs de comparaison comme ==, <, >, <=, >= et !=. Ces opérateurs sont équivalents à np.equal(a, b), np.less(a, b), np.greater(a, b), np.less_equal(a,b), np.greater_equal(a,b) et np.not_equal(a,b).
  • Le produit matriciel avec np.dot().
  • Le produit scalaire np.vdot(a,b)

D’autres fonctions permettent d’effectuer des traitements sans avoir à parcourir le tableau en utilisant des boucles, par exemple:

  • Obtenir le minimum parmi les valeurs du tableau avec np.amin(). Pour obtenir le minimum par ligne: np.amin(a, axis=0); le minimum par colonne: np.amin(a, axis=1).
  • Obtenir le maximum parmi les valeurs du tableau avec np.amax(). Pour obtenir le minimum par ligne: np.amax(a, axis=0); le minimum par colonne: np.amax(a, axis=1).
  • Obtenir l’index du minimum en disposant les données à plat du tableau avec np.argmin(). Pour obtenir les index des minimums par ligne: np.argmin(a, axis=0); les index des minimums par colonne: np.argmin(a, axis=1).
  • Obtenir l’index du maximum en disposant les données à plat du tableau avec np.argmax(). Pour obtenir les index des minimums par ligne: np.argmax(a, axis=0); les index des minimums par colonne: np.argmax(a, axis=1).
  • Obtenir la somme des éléments du tableau avec np.sum(); la somme par ligne des éléments avec np.sum(a, axis=0); la somme par colonne des éléments avec np.sum(a, axis=1).
  • Obtenir le produit des éléments du tableau avec np.prod().
  • Obtenir la moyenne des éléments du tableau avec np.mean().
Références