Tutoriel Python sur les structures de données

Les structures de données sont un moyen d'organiser et de stocker les données de manière à pouvoir y accéder et les utiliser efficacement. Ils définissent la relation entre les données et les opérations qui peuvent être effectuées sur les données. Il existe de nombreux types de structures de données qui permettent aux scientifiques et aux ingénieurs en informatique de se concentrer sur la résolution de problèmes plus vastes plutôt que de se perdre dans les détails de la description et de l'accès aux données.

Dans ce tutoriel, vous découvrirez les différentes structures de données Python et verrez comment elles sont mises en œuvre :

• Type de données abstraites et structures de données
• Structures de données primitives
  • Entiers
  • Flotteur
  • Cordes
  • Booléen
• Structures de données non primitives
  • Tableaux
  • Listes
  • Tuples
  • Dictionnaire
  • Jeux
  • Fichiers

Dans le cours gratuit Intro to Python for Data Science de DataCamp, vous pouvez en apprendre davantage sur l'utilisation de Python spécifiquement dans le contexte de la science des données. Le cours donne une introduction aux concepts de base de Python. Vous y découvrirez les méthodes, les fonctions et le paquetage NumPy.

Type de données abstraites et structures de données

Comme vous l'avez lu dans l'introduction, les structures de données vous permettent de vous concentrer sur la situation dans son ensemble plutôt que de vous perdre dans les détails. C'est ce qu'on appelle l'abstraction de données.

Les structures de données sont en fait une implémentation des types de données abstraits (ADT). Cette mise en œuvre nécessite une vue physique des données à l'aide d'un ensemble de constructions de programmation et de types de données de base.

En général, les structures de données peuvent être divisées en deux catégories en informatique : les structures de données primitives et les structures de données non primitives. Les premières sont les formes les plus simples de représentation des données, tandis que les secondes sont plus avancées : elles contiennent des structures de données primitives à l'intérieur de structures de données plus complexes destinées à des fins particulières.

Structures de données primitives

Il s'agit des structures de données les plus primitives ou les plus élémentaires. Ils constituent les éléments de base de la manipulation des données et contiennent des valeurs de données pures et simples. Python dispose de quatre types de variables primitives :

• Entiers
• Flotteur
• Cordes
• Booléen

Dans les prochaines sections, vous en saurez plus sur eux !

Entiers

Vous pouvez utiliser un nombre entier pour représenter des données numériques et, plus précisément, des nombres entiers compris entre l'infini négatif et l'infini, comme 4, 5 ou -1.

Flotteur

Float" est l'abréviation de "floating point number" (nombre à virgule flottante). Vous pouvez l'utiliser pour les nombres rationnels, qui se terminent généralement par un chiffre décimal, comme 1,11 ou 3,14.

Jetez un coup d'œil sur le DataCamp Light Chunk suivant et essayez certaines des opérations sur les nombres entiers et les flottants !

Notez qu 'en Python, vous n'avez pas besoin d'indiquer explicitement le type de la variable ou de vos données. En effet, il s'agit d'un langage à typage dynamique. Les langages à typage dynamique sont des langages dans lesquels le type de données qu'un objet peut stocker est mutable.

Chaîne

Les chaînes de caractères sont des collections d'alphabets, de mots ou d'autres caractères. En Python, vous pouvez créer des chaînes de caractères en enfermant une séquence de caractères dans une paire de guillemets simples ou doubles. Par exemple : 'cake', "cookie", etc.

Vous pouvez également appliquer les opérations + à deux ou plusieurs chaînes de caractères pour les concaténer, comme dans l'exemple ci-dessous :

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

Voici quelques autres opérations de base que vous pouvez effectuer avec des chaînes de caractères ; Par exemple, vous pouvez utiliser * pour répéter une chaîne de caractères un certain nombre de fois :

# Repeat
x * 2

'CakeCake'

Vous pouvez également découper des chaînes, ce qui signifie que vous sélectionnez des parties de chaînes :

# Range Slicing
z1 = x[2:] 

print(z1)

# Slicing
z2 = y[0] + y[1] 

print(z2)

ke
Co

Notez que les chaînes peuvent également être constituées de caractères alphanumériques, mais que l'opération + est toujours utilisée pour concaténer des chaînes.

x = '4'
y = '2'

x + y

'42'

Python dispose de nombreuses méthodes intégrées ou fonctions d'aide pour manipuler les chaînes de caractères. Remplacer une sous-chaîne, mettre en majuscule certains mots dans un paragraphe, trouver la position d'une chaîne dans une autre chaîne sont autant de manipulations courantes des chaînes de caractères. Découvrez-en quelques-uns :

• Les chaînes de caractères en majuscules

str.capitalize('cookie')

'Cookie'

• Récupère la longueur d'une chaîne de caractères en caractères. Notez que les espaces comptent également dans le résultat final :

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

• Vérifier si une chaîne de caractères est composée uniquement de chiffres

str1.isdigit()

False

str2.isdigit()

True

• Remplacer des parties de chaînes par d'autres chaînes

str1.replace('4 U', str2)

'Cake 404'

• Recherche de sous-chaînes dans d'autres chaînes ; renvoie l'indice ou la position la plus basse dans la chaîne à laquelle la sous-chaîne est trouvée :

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

La sous-chaîne

'cook'

se trouve au début de l'article

'cookie'

. Par conséquent, vous vous référez à la position au sein de

'cookie'

à laquelle vous trouvez cette sous-chaîne. En l'occurrence,

0

est renvoyé parce que vous commencez à compter les positions à partir de 0 !

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

De même, la chaîne de caractères

'cook'

se trouve en position 12 à l'intérieur de

'I got you a cookie'

. N'oubliez pas que vous commencez à compter à partir de 0 et que les espaces comptent pour les positions !

Vous trouverez une liste exhaustive des méthodes de chaînes de caractères en Python ici.

Booléen

Ce type de données intégré peut prendre les valeurs : True et False, ce qui les rend souvent interchangeables avec les entiers 1 et 0. Les booléens sont utiles dans les expressions conditionnelles et de comparaison, comme dans les exemples suivants :

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Comparison expression (Evaluates to false)
if z: # Conditional on truth/false value of 'z'
    print("Cookie")
else: print("No Cookie")

No Cookie

Conversion des types de données

Parfois, vous vous retrouverez à travailler sur le code de quelqu'un d'autre, et vous devrez par exemple convertir un nombre entier en nombre flottant ou vice versa. Ou bien vous vous apercevez que vous avez utilisé un nombre entier alors que vous avez besoin d'un nombre flottant. Dans ce cas, vous pouvez convertir le type de données des variables !

Pour vérifier le type d'un objet en Python, utilisez la fonction intégrée type(), comme dans les lignes de code ci-dessous :

i = 4.0
type(i)

float

Lorsque vous changez le type d'une entité d'un type de données à un autre, on parle de "typecasting". Deux types de conversions de données sont possibles : les conversions implicites, appelées coercition, et les conversions explicites, souvent appelées casting.

Conversion implicite des types de données

Il s'agit d'une conversion automatique des données, que le compilateur gère pour vous. Examinez les exemples suivants :

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

Dans l'exemple ci-dessus, vous n'avez pas eu à modifier explicitement le type de données de y pour effectuer la division de la valeur flottante. Le compilateur l'a fait implicitement pour vous.

C'est facile !

Conversion explicite des types de données

Ce type de conversion de type de données est défini par l'utilisateur, ce qui signifie que vous devez informer explicitement le compilateur pour modifier le type de données de certaines entités. Examinez le morceau de code ci-dessous pour bien comprendre :

x = 2
y = "The Godfather: Part "
fav_movie = y + x

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly

L'exemple ci-dessus vous a donné une erreur parce que le compilateur ne comprend pas que vous essayez d'effectuer une concaténation ou une addition à cause des types de données mélangés. Vous avez un entier et une chaîne de caractères que vous essayez d'additionner.

Il y a un décalage évident.

Pour résoudre ce problème, vous devez d'abord convertir le int en string afin de pouvoir effectuer la concaténation.

Notez qu' il n'est pas toujours possible de convertir un type de données en un autre. Voici quelques fonctions intégrées de conversion de données que vous pouvez utiliser ici : int(), float(), et str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

Structures de données non primitives

Les types non primitifs sont les membres sophistiqués de la famille des structures de données. Ils ne stockent pas seulement une valeur, mais plutôt une collection de valeurs dans différents formats.

Dans le monde de l'informatique traditionnelle, les structures de données non primitives sont divisées en plusieurs catégories :

• Tableaux
• Listes
• Fichiers

Réseau

Tout d'abord, les tableaux en Python sont un moyen compact de collecter des types de données de base, toutes les entrées d'un tableau doivent être du même type de données. Cependant, les tableaux ne sont pas si populaires en Python, contrairement aux autres langages de programmation tels que C++ ou Java.

En général, lorsque les gens parlent de tableaux en Python, ils font en réalité référence à des listes. Cependant, il existe une différence fondamentale entre les deux, et vous le verrez dans quelques instants. Pour Python, les tableaux peuvent être considérés comme un moyen plus efficace de stocker un certain type de liste. Ce type de liste comporte cependant des éléments du même type de données.

En Python, les tableaux sont pris en charge par le module array et doivent être importés avant que vous ne commenciez à les initialiser et à les utiliser. Les éléments stockés dans un tableau sont limités dans leur type de données. Le type de données est spécifié lors de la création du tableau et précisé à l'aide d'un code de type, qui est un caractère unique comme le I que vous voyez dans l'exemple ci-dessous :

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

La page de documentation Python Array fournit plus d'informations sur les différents types de codes disponibles et les fonctionnalités offertes par le module array.

Liste

Les listes en Python sont utilisées pour stocker des collections d'éléments hétérogènes. Ils sont mutables, ce qui signifie que vous pouvez modifier leur contenu sans changer leur identité. Vous pouvez reconnaître les listes à leurs crochets [ et ] qui contiennent des éléments séparés par une virgule ,. Les listes sont intégrées à Python : vous n'avez pas besoin de les invoquer séparément.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Remarque: comme vous l'avez vu dans l'exemple ci-dessus avec x1, les listes peuvent également contenir des éléments homogènes et donc satisfaire à la fonctionnalité de stockage d'un tableau. Cela ne pose pas de problème, sauf si vous souhaitez appliquer des opérations spécifiques à cette collection.

Python fournit de nombreuses méthodes pour manipuler et travailler avec des listes. L'ajout de nouveaux éléments à une liste, la suppression de certains éléments d'une liste et le tri ou l'inversion d'une liste sont des manipulations courantes des listes. Voyons-en quelques-uns en action :

• Ajoutez 11 à la liste list_num avec append(). Par défaut, ce numéro sera ajouté à la fin de la liste.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Utilisez insert() pour insérer 11 à l'index ou à la position 0 dans la liste list_num.

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Supprimez la première occurrence de 'o' sur list_char à l'aide de remove()

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• Supprimez l'élément à l'index -2 de list_char

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Si vous souhaitez en savoir plus sur les listes en Python, vous pouvez facilement parcourir le tutoriel 18 questions les plus courantes sur les listes en Python!

Tableaux et listes

Maintenant que vous avez vu des listes en Python, vous vous demandez peut-être pourquoi vous avez besoin de tableaux. La raison en est qu'ils sont fondamentalement différents en termes d'opérations que l'on peut effectuer sur eux. Avec les tableaux, vous pouvez facilement effectuer des opérations sur tous leurs éléments individuellement, ce qui n'est pas toujours le cas avec les listes. En voici une illustration :

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

Vous avez pu appliquer la fonction tostring() du site array_char parce que Python sait que tous les éléments d'un tableau sont du même type de données et que, par conséquent, l'opération se comporte de la même manière sur chaque élément. Les tableaux peuvent donc être très utiles lorsqu'il s'agit d'une grande collection de types de données homogènes. Comme Python n'a pas à se souvenir des détails du type de données de chaque élément individuellement, pour certaines utilisations, les tableaux peuvent être plus rapides et utiliser moins de mémoire que les listes.

Il est également utile de mentionner le tableau NumPy, puisque nous parlons de tableaux. Les tableaux NumPy sont très utilisés dans le monde de la science des données pour travailler avec des tableaux multidimensionnels. Ils sont plus efficaces que le module array et les listes Python en général. La lecture et l'écriture d'éléments dans un tableau NumPy sont plus rapides, et ils prennent en charge les opérations "vectorisées" telles que l'addition par élément. De plus, les tableaux NumPy fonctionnent efficacement avec les grands ensembles de données éparses. Pour en savoir plus, consultez le tutoriel Python Numpy Array de DataCamp.

Voici un peu de code pour vous aider à démarrer avec NumPy Array :

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Traditionnellement, les structures de données de type liste peuvent être classées en structures de données linéaires et non linéaires. Stacks Les structures de données de type "liste" et "liste" sont appelées "structures linéaires". Queues sont appelées "structures de données linéaires", tandis que Graphs et Trees sont des "structures de données non linéaires". Ces structures et leurs concepts peuvent être relativement complexes mais sont largement utilisés en raison de leur ressemblance avec les modèles du monde réel. Vous aurez un aperçu de ces sujets dans ce tutoriel.

Remarque: dans une structure de données linéaire, les éléments de données sont organisés de manière séquentielle ou, en d'autres termes, linéaire. Les éléments de données sont parcourus en série l'un après l'autre et tous les éléments de données d'une structure de données linéaire peuvent être parcourus en une seule fois. Toutefois, dans les structures de données non linéaires, les éléments de données ne sont pas organisés de manière séquentielle. Cela signifie que les éléments peuvent être reliés à plus d'un élément afin de refléter une relation particulière entre ces éléments. Tous les éléments d'une structure de données non linéaire peuvent ne pas être parcourus au cours d'une seule exécution.

Piles

Une pile est un conteneur d'objets qui sont insérés et retirés selon le principe du dernier entré, premier sorti (LIFO). Imaginez un scénario dans lequel, lors d'un dîner où il y a une pile d'assiettes, des assiettes sont toujours ajoutées ou retirées du haut de la pile. En informatique, ce concept est utilisé pour l'évaluation des expressions et l'analyse syntaxique, l'ordonnancement des algorithmes/routines, etc.

Les piles peuvent être mises en œuvre à l'aide de listes en Python. Lorsque vous ajoutez des éléments à une pile, il s'agit d'une opération "push", tandis que lorsque vous retirez ou supprimez un élément, il s'agit d'une opération "pop". Notez que vous disposez en fait d'une méthode pop() lorsque vous travaillez avec des piles en Python :

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

File d'attente

Une file d'attente est un conteneur d'objets qui sont insérés et retirés selon le principe du premier entré-premier sorti (FIFO). Un excellent exemple de file d'attente dans le monde réel est la file d'attente à un guichet où les personnes sont accueillies en fonction de leur ordre d'arrivée, et donc la personne qui arrive en premier est aussi la première à partir. Les files d'attente peuvent être de différents types.

Les listes ne sont pas efficaces pour mettre en œuvre une file d'attente, car append() et pop() à partir de la fin d'une liste ne sont pas rapides et entraînent un coût de déplacement de la mémoire. De même, l'insertion à la fin et la suppression au début d'une liste ne sont pas si rapides puisqu'elles nécessitent un décalage dans la position des éléments.

Graphiques

En mathématiques et en informatique, les graphes sont des réseaux constitués de nœuds, également appelés sommets, qui peuvent ou non être connectés les uns aux autres. Les lignes ou le chemin qui relient deux nœuds sont appelés arêtes. Si l'arête a une direction particulière, il s'agit d'un graphe orienté, l'arête de direction étant appelée arc. Dans le cas contraire, si aucune direction n'est spécifiée, le graphe est appelé graphe non orienté.

Tout cela peut sembler très théorique et peut s'avérer assez complexe lorsque l'on creuse un peu plus. Cependant, les graphes sont un concept important, en particulier dans le domaine de la science des données, et sont souvent utilisés pour modéliser des problèmes de la vie réelle. Les réseaux sociaux, les études moléculaires en chimie et en biologie, les cartes et les systèmes de recommandation reposent tous sur les principes des graphes et de la théorie des graphes.

Vous trouverez ici une implémentation simple d'un graphe utilisant un dictionnaire Python pour vous aider à démarrer :

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Vous pouvez faire des choses intéressantes avec les graphes, comme essayer de trouver s'il existe un chemin entre deux nœuds ou trouver le chemin le plus court entre deux nœuds, déterminer les cycles dans le graphe.

Le célèbre "problème du voyageur de commerce" consiste en fait à trouver l'itinéraire le plus court possible qui passe par chaque nœud exactement une fois et revient au point de départ. Parfois, les nœuds ou les arcs d'un graphe ont été affectés d'un poids ou d'un coût, ce qui revient à attribuer un niveau de difficulté à la marche, et vous cherchez à trouver le chemin le moins cher ou le plus facile.

Arbres

Dans le monde réel, un arbre est un être vivant avec ses racines dans le sol et les branches qui portent les feuilles et les fruits à l'air libre. Les branches de l'arbre s'étendent de manière quelque peu organisée. En informatique, les arbres sont utilisés pour décrire la manière dont les données sont parfois organisées, sauf que la racine se trouve au sommet et que les branches, les feuilles, suivent en s'étendant vers le bas et que l'arbre est dessiné à l'envers par rapport à l'arbre réel.

Pour introduire un peu plus de notation, la racine se trouve toujours au sommet de l'arbre. Pour rester dans la métaphore de l'arbre, les autres nœuds qui suivent sont appelés les branches et le dernier nœud de chaque branche est appelé la feuille. Vous pouvez imaginer que chaque branche est un petit arbre en soi. La racine est souvent appelée "parent" et les nœuds auxquels elle fait référence en dessous sont appelés "enfants". Les nœuds ayant le même parent sont appelés frères et sœurs. Vous comprenez pourquoi on parle aussi d'arbre généalogique ?

Les arbres permettent de définir des scénarios réels et sont utilisés partout, du monde des jeux à la conception d'analyseurs XML, en passant par le principe de conception des PDF, qui repose sur les arbres. Dans le domaine de la science des données, l'apprentissage basé sur les arbres de décision constitue un vaste domaine de recherche. De nombreuses méthodes célèbres existent, comme le bagging, le boosting, qui utilisent le modèle d'arbre pour générer un modèle prédictif. Les jeux comme les échecs construisent un énorme arbre avec tous les mouvements possibles à analyser et appliquent une heuristique pour décider du mouvement optimal.

Vous pouvez mettre en place une structure arborescente en utilisant et en combinant les différentes structures de données que vous avez vues jusqu'à présent dans ce tutoriel. Toutefois, par souci de simplicité, ce sujet sera abordé dans un autre article.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Vous avez appris ce que sont les tableaux et vous avez vu la structure de données liste. Cependant, Python propose de nombreux types de mécanismes de collecte de données, et bien qu'ils ne soient pas forcément inclus dans les sujets traditionnels sur les structures de données en informatique, ils valent la peine d'être connus, en particulier en ce qui concerne le langage de programmation Python :

• Tuples
• Dictionnaire
• Jeux

Tuples

Les tuples sont un autre type de données de séquence standard. La différence entre les tuples et les listes est que les tuples sont immuables, ce qui signifie qu'une fois définis, vous ne pouvez pas supprimer, ajouter ou modifier les valeurs qu'ils contiennent. Cela peut s'avérer utile lorsque vous souhaitez transmettre le contrôle à quelqu'un d'autre, mais que vous ne souhaitez pas qu'il manipule les données de votre collection, mais qu'il se contente de les voir ou d'effectuer des opérations séparément dans une copie des données.

Voyons comment les tuples sont mis en œuvre :

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Dictionnaire

Les dictionnaires sont exactement ce dont vous avez besoin si vous voulez mettre en œuvre quelque chose de similaire à un annuaire téléphonique. Aucune des structures de données que vous avez vues précédemment ne convient à un annuaire téléphonique.

C'est là qu'un dictionnaire peut s'avérer utile. Les dictionnaires sont constitués de paires clé-valeur. key est utilisé pour identifier l'élément et value contient, comme son nom l'indique, la valeur de l'élément.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Vous pouvez appliquer de nombreuses autres fonctionnalités intégrées aux dictionnaires :

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Ce code montre un exemple d'utilisation d'un dictionnaire Python pour stocker et accéder à des paires clé-valeur.

Tout d'abord, le code appelle la fonction len() avec x_dict comme argument. Ceci renvoie le nombre de paires clé-valeur dans le dictionnaire, qui est de 3.

Ensuite, le code appelle la méthode keys() sur x_dict. Cette méthode renvoie un objet de vue contenant les clés du dictionnaire. Dans ce cas, les clés sont 'Prem', 'Edward' et 'Jorge', comme le montre la sortie.

Ensuite, le code appelle la méthode values() sur x_dict. Cette méthode renvoie un objet de vue contenant les valeurs du dictionnaire. Dans ce cas, les valeurs sont respectivement 3, 1 et 2, comme le montre la sortie.

Jeux

Les ensembles sont une collection d'objets distincts (uniques). Elles sont utiles pour créer des listes qui ne contiennent que des valeurs uniques dans l'ensemble de données. Il s'agit d'une collection non ordonnée mais mutable, ce qui est très utile lorsque vous parcourez un énorme ensemble de données.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

 in ()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

Le code crée deux ensembles : x_set et y_set. Chaque ensemble est créé en transmettant une chaîne de caractères comme argument à la fonction set(). Dans ce cas, x_set est créé à partir de la chaîne "CAKE&COKE", tandis que y_set est créé à partir de la chaîne "COOKIE".

Ensuite, le code imprime chaque jeu à l'aide de la fonction print(). La première instruction print() imprime x_set, qui contient les caractères uniques de la chaîne "CAKE&COKE". Le résultat montre que x_set contient les caractères 'A', '&', 'O', 'E', 'C' et 'K'. De même, la deuxième instruction print() imprime y_set, qui contient les caractères uniques de la chaîne "COOKIE". Le résultat montre que y_set contient les caractères 'I', 'O', 'E', 'C' et 'K'.

La troisième instruction print() tente d'imprimer l'ensemble de tous les éléments de x_set qui ne se trouvent pas dans y_set. Cependant, cette ligne de code aboutit à NameError car la variable x n'a pas été définie. Vraisemblablement, cette ligne devrait être remplacée par print(x_set - y_set).

La quatrième instruction print() imprime l'ensemble des éléments uniques dans x_set ou y_set, ou les deux. Le résultat montre que l'ensemble obtenu contient tous les caractères uniques de x_set et y_set.

Enfin, la cinquième instruction print() imprime l'ensemble des éléments qui se trouvent à la fois dans x_set et y_set. Le résultat montre que cet ensemble contient les caractères "O", "E", "K" et "C".

Fichiers

Les fichiers font traditionnellement partie des structures de données. Et bien que les données volumineuses soient monnaie courante dans le secteur de la science des données, un langage de programmation qui n'aurait pas la capacité de stocker et d'extraire des informations précédemment stockées ne serait guère utile. Vous devez encore utiliser toutes les données contenues dans les fichiers des bases de données et vous apprendrez à le faire.

La syntaxe pour lire et écrire des fichiers en Python est similaire à celle des autres langages de programmation, mais beaucoup plus facile à manipuler. Voici quelques-unes des fonctions de base qui vous aideront à travailler avec des fichiers à l'aide de Python :

• open() pour ouvrir des fichiers dans votre système, le nom de fichier est le nom du fichier à ouvrir ;
• read() pour lire des fichiers entiers ;
• readline() pour lire une ligne à la fois ;
• write() pour écrire une chaîne de caractères dans un fichier et renvoyer le nombre de caractères écrits ; et
• close() pour fermer le fichier.

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

Le deuxième argument de la fonction open() est le mode de fichier. Il vous permet de spécifier si vous voulez lire (r), écrire (w), ajouter (a) ou à la fois lire et écrire (r+).

Pour en savoir plus sur la gestion des fichiers en Python, consultez cette page.

Vous avez réussi !

Hourra ! Vous avez atteint la fin de ce tutoriel ! Vous vous rapprochez ainsi de votre rêve de conquérir le monde de la science des données.

Si cela vous intéresse, la boîte à outils Python Data Science en deux parties de DataCamp plonge plus profondément dans les fonctions, les itérateurs, les listes, etc.

Faites une pause et lorsque vous serez prêt, dirigez-vous vers l'un des tutoriels recommandés pour poursuivre votre voyage !