Les séquences, les dictionnaires et les ensembles sont des structures de données fondamentales dans les langages de programmation tels que Python. Elles jouent un rôle essentiel dans la gestion et la manipulation des données au sein des programmes.

• Les séquences sont des collections ordonnées d'éléments accessibles par leur index. Python propose plusieurs types de séquences, notamment des listes, des tuples et des chaînes, chacun ayant ses propres caractéristiques et utilisations. Les séquences sont utiles pour des tâches telles que la manipulation de données, le filtrage et le tri.
• Les dictionnaires sont des collections non ordonnées de paires clé-valeur, où chaque clé est unique et correspond à une valeur spécifique. Les dictionnaires sont un outil puissant pour stocker et récupérer des données, et sont largement utilisés en Python pour des tâches telles que l'analyse de données et le développement web.
• Les ensembles, également connus sous le nom de sets, sont des collections non ordonnées d'éléments uniques. Les ensembles sont utiles pour des tâches telles que la suppression des doublons d'une liste, l'exécution d'opérations sur les ensembles (par exemple, l'union, l'intersection) et la vérification de l'appartenance.

Ensemble, ces structures de données fournissent aux programmeurs des outils puissants pour gérer et manipuler les données en Python. Elles sont essentielles pour de nombreuses tâches, de la simple manipulation de données à l'analyse de données complexes et à l'apprentissage automatique. Comprendre ces structures de données et savoir les utiliser efficacement est une compétence importante pour tout programmeur Python.

Les sequences

En Python, une séquence est une collection ordonnée d'objets qui peut être indexée et découpée. Les séquences constituent une structure de données fondamentale en Python et sont largement utilisées dans de nombreuses applications. Il existe plusieurs types de séquences en Python :

• Les listes : Une liste est une séquence mutable qui peut contenir des éléments de différents types de données.
• Tuples : Un tuple est une séquence immuable qui peut contenir des éléments de différents types de données.
• Chaînes : Une chaîne est une séquence immuable de caractères.
• Plages : Une plage est une séquence immuable d'entiers.
• Tableaux d'octets : Un tableau d'octets est une séquence mutable d'octets.

Les séquences en Python peuvent être indexées, ce qui signifie que les éléments individuels de la séquence peuvent être accédés par leur position dans la séquence. L'indexation commence à 0 pour le premier élément et se poursuit de manière incrémentale pour chaque élément suivant. Les séquences en Python peuvent également être découpées, ce qui signifie qu'un sous-ensemble de la séquence peut être extrait en spécifiant une plage d'indices. Le découpage s'effectue à l'aide de l'opérateur deux-points, et la tranche résultante comprend tous les éléments à partir de l'indice de départ jusqu'à l'indice de fin, mais sans l'inclure. Par exemple, le code suivant crée une liste d'entiers et accède à des éléments individuels en utilisant l'indexation et le découpage :

my_list = [1, 2, 3, 4, 5]
print(my_list[0])   # prints 1
print(my_list[2])   # prints 3
print(my_list[:3])  # prints [1, 2, 3]
print(my_list[3:])  # prints [4, 5]

Les séquences en Python supportent également diverses fonctions intégrées, telles que len() pour obtenir la longueur de la séquence, min() et max() pour trouver les valeurs minimum et maximum dans la séquence, et sorted() pour trier la séquence. En résumé, les séquences sont une structure de données importante et sont largement utilisées dans de nombreuses applications. Elles constituent un moyen puissant de stocker et de manipuler des collections ordonnées d'objets et sont prises en charge par un grand nombre de fonctions et d'opérateurs intégrés.

Les dictionnaires

En Python, un dictionnaire est une collection de paires clé-valeur, où chaque clé est associée à une valeur. Dans d'autres langages de programmation, les dictionnaires sont parfois appelés tableaux associatifs, cartes ou tables de hachage. La clé est utilisée pour identifier de manière unique une valeur, de la même manière qu'un mot est utilisé pour rechercher sa définition dans un dictionnaire traditionnel. Les dictionnaires sont définis à l'aide d'accolades {} et les paires clé-valeur sont séparées par deux points :. Par exemple, le code suivant définit un dictionnaire qui associe des noms à des âges :

my_dict = {'Alice': 25, 'Bob': 30, 'Charlie': 35}

Dans cet exemple, "Alice", "Bob" et "Charlie" sont les clés et 25, 30 et 35 sont les valeurs correspondantes. Pour accéder à la valeur associée à une clé particulière, vous pouvez utiliser la notation entre crochets avec la clé comme index. Par exemple, pour accéder à la valeur associée à la clé "Alice", vous devez écrire :

print(my_dict['Alice'])   # prints 25

Vous pouvez également ajouter de nouvelles paires clé-valeur à un dictionnaire ou modifier des paires existantes en attribuant une nouvelle valeur à la clé correspondante, ou encore supprimer une association. Par exemple, il est possible d'ajouter des paires clé-valeur à un dictionnaire :

my_dict['David'] = 40   # adds a new key-value pair
my_dict['Bob'] = 31     # modifies the value associated with the key 'Bob'
del my_dict['Alice']    # remove 'Alice' key and there associated value

Les dictionnaires sont un outil puissant pour stocker et manipuler des données en Python. Ils sont fréquemment utilisés pour des tâches telles que le traitement des données, l'accès aux bases de données et le développement web. Les méthodes intégrées aux dictionnaires, telles que keys(), values() et items(), facilitent la manipulation et l'itération à travers les clés et les valeurs d'un dictionnaire. Dans l'ensemble, les dictionnaires sont une structure de données flexible et efficace qui constitue un élément clé de nombreux programmes.

Les enssembles

En Python, un ensemble (ou set) est une collection d'éléments uniques. Contrairement à une liste ou à un tuple, qui peuvent contenir des doublons, un ensemble ne contient que des valeurs distinctes. Les ensembles sont définis à l'aide d'accolades {} et les éléments sont séparés par des virgules. Par exemple, le code suivant définit un ensemble d'entiers :

my_set = {1, 2, 3, 4, 5}

Dans cet exemple, l'ensemble contient les entiers de 1 à 5. Les ensembles permettent d'effectuer diverses opérations telles que l'union, l'intersection, la différence et la différence symétrique. Par exemple, l'union de deux ensembles peut être calculée à l'aide de la méthode union() ou de l'opérateur | :

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
# or
union_set = set1 | set2

L'ensemble union_set qui en résulte contient les éléments {1, 2, 3, 4, 5}. De même, l'intersection de deux ensembles peut être calculée à l'aide de la méthode intersection() ou de l'opérateur & :

intersection_set = set1.intersection(set2)
# or
intersection_set = set1 & set2

L'ensemble intersection_set résultant contient l'élément {3}. D'autres opérations sur les ensembles comme difference(), symmetric_difference(), et issubset() sont également disponibles. Les ensembles constituent un outil puissant pour effectuer des opérations sur les ensembles, supprimer les doublons des listes ou d'autres séquences et tester l'appartenance. La flexibilité et l'efficacité des ensembles en font une structure de données utile pour de nombreuses application.

TODO

https://github.com/bc-maia/udacity_python_language/blob/master/A%20-%20Basics/2-DataStructures.py