Construire des ensembles

list() : construire une liste

list() crée une liste à partir d'un itérable, ou une liste vide sans argument.

print(list("ABC"))        # ['A', 'B', 'C']
print(list(range(3)))     # [0, 1, 2]

À partir d'une liste existante, elle crée une copie superficielle : les objets contenus dans les listes sont les mêmes.

Equivalent en C#

List<char> letters = "ABC".ToList();
List<int> numbers = Enumerable.Range(0, 3).ToList();
List<int> copy = new List<int>(numbers);

Le type List<T> est générique et contient des éléments de type T. Une liste Python peut mélanger plusieurs types.

tuple() : construire un tuple

tuple() construit une séquence dont les éléments ne peuvent pas être remplacés, ajoutés ou supprimés.

coordinates = tuple([10, 20])
print(coordinates)  # (10, 20)

Un tuple peut néanmoins contenir un objet mutable, comme une liste.

Equivalent en C#

(int X, int Y) coordinates = (10, 20);
Console.WriteLine(coordinates.X); // 10
coordinates.X = 30;               // Autorisé avec ValueTuple
Tuple<int, int> fixedPair = Tuple.Create(10, 20);

Un tuple Python est une séquence de longueur quelconque. Les tuples C# ont des types de champs définis. Les tuples ValueTuple sont des types valeur mutables et System.Tuple expose des éléments en lecture seule.

dict() : construire un dictionnaire

dict() crée des associations entre des clés et des valeurs. Les clés doivent être hachables.

product = dict(name="Clavier", price=69.90)
pairs = dict([("language", "Python"), ("version", 3)])
print(product["name"])  # Clavier

Les dictionnaires conservent l'ordre d'insertion des clés.

Equivalent en C#

var product = new Dictionary<string, object>
{
    ["name"] = "Clavier",
    ["price"] = 69.90
};
Console.WriteLine(product["name"]); // Clavier

Dictionary<TKey, TValue> est l’équivalent courant. Un comparateur .NET définit l’égalité et le hachage des clés. Python garantit l’ordre d’insertion des dictionnaires ; ne supposons pas que cette garantie fait partie du contrat de Dictionary<TKey, TValue>.

set() : construire un ensemble

set() permet de créer une collection d'éléments distincts et hachables. Elle ne garantit pas d'ordre d'itération.

numbers = set([3, 1, 3, 2])
print(sorted(numbers))  # [1, 2, 3]

Un ensemble vide s'écrit set() et {} construit un dictionnaire vide.

Equivalent en C#

var numbers = new HashSet<int>(new[] { 3, 1, 3, 2 });
Console.WriteLine(string.Join(", ", numbers.OrderBy(n => n))); // 1, 2, 3

Le type HashSet<T> élimine les doublons et propose des opérations ensemblistes très performantes.

frozenset() : construire un ensemble immuable

frozenset() construit un ensemble qui ne peut plus être modifié. Il est lui-même hachable et peut servir de clé de dictionnaire.

permissions = frozenset(["read", "write", "read"])
print(len(permissions))          # 2 var "read" apparaît deux fois
print("read" in permissions)     # True

Equivalent en C#

var permissions = new[] { "read", "write", "read" }.ToFrozenSet();
Console.WriteLine(permissions.Count);            // 2
Console.WriteLine(permissions.Contains("read")); // True

Le type FrozenSet<T> (à partir de .NET 8+) est un ensemble de données / d'objets construit une fois, puis optimise les recherches.