Vos premiers pas dans la science des données en Python – Real Python

Utilisation de Repl.it comme éditeur en ligne

Si vous voulez simplement commencer avec quelques exemples, suivez ce didacticiel et commencez à créer de la mémoire musculaire avec NumPy, Repl.it est une excellente option pour l'édition dans le navigateur. Vous pouvez vous inscrire et lancer un environnement Python en quelques minutes. Sur le côté gauche, il y a un onglet pour les packages. Vous pouvez en ajouter autant que vous le souhaitez. Pour ce didacticiel NumPy, utilisez les versions actuelles de NumPy et Matplotlib.

Voici où vous pouvez trouver les packages dans l'interface:

Heureusement, ils vous permettent de cliquer et d'installer.

Installation de NumPy avec Anaconda

La distribution Anaconda est une suite d'outils communs de science des données Python regroupés autour d'un directeur chargé d'emballage qui aide à gérer vos environnements virtuels et les dépendances de projet. Il est construit autour conda, qui est le véritable gestionnaire de paquets. C'est la méthode recommandée par le projet NumPy, en particulier si vous vous lancez dans la science des données en Python sans avoir déjà configuré un environnement de développement complexe.

Si vous avez déjà un workflow que vous aimez et qui utilise pépin, Pipenv, Poetry ou un autre ensemble d'outils, il serait peut-être préférable de ne pas ajouter conda au mélange. le conda le référentiel de packages est séparé de PyPI, et conda lui-même met en place un petit îlot séparé de paquets sur votre machine, donc gérer les chemins et se souvenir de quel paquet vit où peut être un cauchemar.

Une fois que vous avez conda installé, vous pouvez exécuter le installer commande pour les bibliothèques dont vous aurez besoin:

$ conda installer numpy matplotlib

Cela installera ce dont vous avez besoin pour ce didacticiel NumPy, et vous serez prêt à partir.

Installation de NumPy avec pépin

Bien que le projet NumPy recommande d'utiliser conda si vous recommencez à neuf, il n'y a rien de mal à gérer vous-même votre environnement et à utiliser simplement du bon vieux pépin, Pipenv, Poetry, ou toute autre alternative à pépin est votre préféré.

Voici les commandes à configurer pépin:

$ mkdir numpy-tutoriel
$ CD tutoriel numpy
$ python3 -m venv .numpy-tutorial-venv
$ la source .numpy-tutorial-venv / bin / activate

(.numpy-tutorial-venv)
$ pip installer numpy matplotlib
Collecter numpy
        Téléchargement de numpy-1.19.1-cp38-cp38-macosx_10_9_x86_64.whl (15,3 Mo)
                    | ████████████████████████████████ | 15,3 Mo 2,7 Mo / s
Collecter matplotlib
        Téléchargement de matplotlib-3.3.0-1-cp38-cp38-macosx_10_9_x86_64.whl (11,4 Mo)
                    | ████████████████████████████████ | 11,4 Mo 16,8 Mo / s
...

Après cela, assurez-vous que votre environnement virtuel est activé et que tout votre code doit s'exécuter comme prévu.

Utilisation d'IPython, de notebooks ou de JupyterLab

Bien que les sections ci-dessus devraient vous fournir tout ce dont vous avez besoin pour commencer, vous pouvez éventuellement installer quelques outils supplémentaires pour rendre le travail dans la science des données plus convivial pour les développeurs.

IPython est une boucle Python read-eval-print (REPL) mise à niveau qui rend l'édition de code dans une session d'interprétation en direct plus simple et plus jolie. Voici à quoi ressemble une session IPython REPL:

Dans [1]: importer engourdi comme np

Dans [2]: chiffres = np.tableau([[[[
            ...:     [[[[1, 2, 3],
            ...:     [[[[4, 5, 6],
            ...:     [[[[6, sept, 9],
            ...: ])

Dans [3]: chiffres
En dehors[3]:
tableau ([[1, 2, 3],
       [4, 5, 6],
       [6, 7, 9]])

Il présente plusieurs différences par rapport à un REPL Python de base, notamment ses numéros de ligne, l'utilisation de couleurs et la qualité des visualisations de tableau. Il existe également de nombreux bonus d'expérience utilisateur qui rendent plus agréable la saisie, la ré-saisie et la modification du code.

Vous pouvez installer IPython de manière autonome:

Sinon, si vous attendez et installez l'un des outils suivants, ils incluront une copie d'IPython.

Une alternative légèrement plus fonctionnelle à une REPL est une carnet. Cependant, les notebooks sont un style d'écriture Python légèrement différent de celui des scripts standard. Au lieu d'un fichier Python traditionnel, ils vous donnent une série de mini-scripts appelés cellules que vous pouvez exécuter et réexécuter dans l'ordre de votre choix, le tout dans la même session de mémoire Python.

Une chose intéressante à propos des blocs-notes est que vous pouvez inclure des graphiques et rendre des paragraphes Markdown entre les cellules, ils sont donc vraiment utiles pour rédiger des analyses de données directement dans le code!

Voici à quoi cela ressemble:

L'offre de bloc-notes la plus populaire est probablement le bloc-notes Jupyter, mais nteract est une autre option qui englobe la fonctionnalité Jupyter et tente de la rendre un peu plus accessible et puissante.

Cependant, si vous regardez Jupyter Notebook et pensez qu'il a besoin de plus de qualités de type IDE, JupyterLab est une autre option. Vous pouvez personnaliser les éditeurs de texte, les blocs-notes, les terminaux et les composants personnalisés, le tout dans une interface basée sur un navigateur. Ce sera probablement plus confortable pour les personnes venant de MatLab. C'est la plus récente des offres, mais sa version 1.0 était de retour en 2019, elle devrait donc être stable et complète.

Voici à quoi ressemble l'interface:

Quelle que soit l'option que vous choisissez, une fois que vous l'avez installée, vous serez prêt à exécuter vos premières lignes de code NumPy. Il est temps pour le premier exemple.

Maîtriser la forme

La forme est un concept clé lorsque vous utilisez des tableaux multidimensionnels. À un moment donné, il est plus facile d’oublier la visualisation de la forme de vos données et de suivre certaines règles mentales et de faire confiance à NumPy pour vous indiquer la forme correcte.

Tous les tableaux ont une propriété appelée .forme qui renvoie un tuple de la taille dans chaque dimension. La dimension est moins importante, mais il est essentiel que les tableaux que vous transmettez aux fonctions aient la forme attendue par les fonctions. Un moyen courant de vérifier que vos données ont la forme appropriée consiste à imprimer les données et leur forme jusqu'à ce que vous soyez sûr que tout fonctionne comme prévu.

Cet exemple suivant montrera ce processus. Vous allez créer un tableau avec une forme complexe, le vérifier et le réorganiser pour qu’il ressemble à ce qu’il est censé:

Dans [1]: importer engourdi comme np

Dans [2]: les températures = np.tableau([[[[
            ...:     29,3, 42,1, 18,8, 16,1, 38,0, 12,5,
            ...:     12,6, 49,9, 38,6, 31,3, 9.2, 22.2
            ...: ]).remodeler(2, 2, 3)

Dans [3]: les températures.forme
En dehors[3]: (2, 2, 3)

Dans [4]: les températures
En dehors[4]:
tableau ([[[29.3, 42.1, 18.8],
        [16.1, 38. , 12.5]],

       [[12.6, 49.9, 38.6],
        [31.3,  9.2, 22.2]]])

Dans [5]: np.swapaxes(les températures, 1, 2)
En dehors[5]:
tableau ([[[29.3, 16.1],
        [42.1, 38. ],
        [18.8, 12.5]],

       [[12.6, 31.3],
        [49.9,  9.2],
        [38.6, 22.2]]])

Ici, vous utilisez un numpy.ndarray méthode appelée .reshape () pour former un bloc de données 2 × 2 × 3. Lorsque vous vérifiez la forme de votre tableau dans l'entrée 3, c'est exactement ce que vous lui avez dit. Cependant, vous pouvez voir comment les tableaux imprimés deviennent rapidement difficiles à visualiser dans trois dimensions ou plus. Après avoir échangé les axes avec .swapaxes (), il devient un peu plus clair quelle dimension est quelle. Vous en verrez plus sur les axes dans la section suivante.

La forme reviendra dans la section sur la diffusion. Pour l'instant, gardez à l'esprit que ces petits chèques ne coûtent rien. Vous pouvez toujours supprimer les cellules ou vous débarrasser du code une fois que tout se passe bien.

Comprendre les axes

L'exemple ci-dessus montre à quel point il est important de savoir non seulement dans quelle forme se trouvent vos données, mais également dans quelles données axe. Dans les tableaux NumPy, les axes sont indexés à zéro et identifient quelle dimension est quelle. Par exemple, un tableau à deux dimensions a un axe vertical (axe 0) et un axe horizontal (axe 1). De nombreuses fonctions et commandes de NumPy modifient leur comportement en fonction de l'axe que vous leur dites de traiter.

Cet exemple montrera comment .max () se comporte par défaut, sans axe argument, et comment il change la fonctionnalité en fonction de axe vous spécifiez quand vous fournissez un argument:

Dans [1]: importer engourdi comme np

Dans [2]: table = np.tableau([[[[
            ...:     [[[[5, 3, sept, 1],
            ...:     [[[[2, 6, sept ,9],
            ...:     [[[[1, 1, 1, 1],
            ...:     [[[[4, 3, 2, 0],
            ...: ])

Dans [3]: table.max()
En dehors[3]: 9

Dans [4]: table.max(axe=0)
En dehors[4]: tableau ([5, 6, 7, 9])

Dans [5]: table.max(axe=1)
En dehors[5]: tableau ([7, 9, 1, 4])

Par défaut, .max () renvoie la plus grande valeur de tout le tableau, quel que soit le nombre de dimensions. Cependant, une fois que vous spécifiez un axe, il effectue ce calcul pour chaque ensemble de valeurs le long de cet axe particulier. Par exemple, avec un argument de axe = 0, .max () sélectionne la valeur maximale dans chacun des quatre ensembles verticaux de valeurs de table et renvoie un tableau qui a été aplati, ou agrégés dans un tableau unidimensionnel.

En fait, de nombreuses fonctions de NumPy se comportent de cette manière: si aucun axe n'est spécifié, elles effectuent une opération sur l'ensemble de données. Sinon, ils effectuent l'opération dans un dans le sens de l'axe mode.

Diffusion

Jusqu'à présent, vous avez vu quelques exemples plus petits de diffusion, mais le sujet commencera à avoir plus de sens au fur et à mesure que vous en verrez. Fondamentalement, il fonctionne autour d'une règle: les tableaux peuvent être diffusés les uns contre les autres si leurs dimensions correspondent ou si l'un des tableaux a une taille de 1.

Si les tableaux correspondent en taille le long d'un axe, alors les éléments seront exploités élément par élément, de la même manière que la fonction Python intégrée Zip *: français() travaux. Si l'un des tableaux a une taille de 1 dans un axe, alors cette valeur sera diffuser le long de cet axe, ou dupliqué autant de fois que nécessaire pour correspondre au nombre d'éléments le long de cet axe dans l'autre tableau.

Voici un exemple rapide. Tableau UNE a la forme (4, 1, 8), et tableau B a la forme (1, 6, 8). Sur la base des règles ci-dessus, vous pouvez opérer sur ces tableaux ensemble:

• Dans l'axe 0, UNE a un 4 et B a un 1, alors B peut être diffusé le long de cet axe.
• Dans l'axe 1, UNE a un 1 et B a un 6, donc UNE peut être diffusé le long de cet axe.
• Dans l'axe 2, les deux tableaux ont des tailles correspondantes, de sorte qu'ils peuvent fonctionner correctement.

Les trois axes suivent avec succès la règle.

Vous pouvez configurer les tableaux comme ceci:

Dans [1]: importer engourdi comme np

Dans [2]: UNE = np.organiser(32).remodeler(4, 1, 8)

Dans [3]: UNE
En dehors[3]:
tableau ([[[ 0,  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, 28, 29, 30, 31]]])

Dans [4]: B = np.organiser(48).remodeler(1, 6, 8)

Dans [5]: B
En dehors[5]:
tableau ([[[ 0,  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, 28, 29, 30, 31],
        [32, 33, 34, 35, 36, 37, 38, 39],
        [40, 41, 42, 43, 44, 45, 46, 47]]])

UNE a 4 avions, chacun avec 1 rangée et 8 Colonnes. B a seulement 1 avion avec 6 lignes et 8 Colonnes. Regardez ce que NumPy fait pour vous lorsque vous essayez de faire un calcul entre eux!

Ajoutez les deux tableaux ensemble:

Dans [7]: UNE + B
En dehors[7]:
tableau ([[[ 0,  2,  4,  6,  8, 10, 12, 14],
        [ 8, 10, 12, 14, 16, 18, 20, 22],
        [16, 18, 20, 22, 24, 26, 28, 30],
        [24, 26, 28, 30, 32, 34, 36, 38],
        [32, 34, 36, 38, 40, 42, 44, 46],
        [40, 42, 44, 46, 48, 50, 52, 54]],

                            [[[[[ 8, 10, 12, 14, 16, 18, 20, 22],
        [16, 18, 20, 22, 24, 26, 28, 30],
        [24, 26, 28, 30, 32, 34, 36, 38],
        [32, 34, 36, 38, 40, 42, 44, 46],
        [40, 42, 44, 46, 48, 50, 52, 54],
        [48, 50, 52, 54, 56, 58, 60, 62]],

                            [[[[[16, 18, 20, 22, 24, 26, 28, 30],
        [24, 26, 28, 30, 32, 34, 36, 38],
        [32, 34, 36, 38, 40, 42, 44, 46],
        [40, 42, 44, 46, 48, 50, 52, 54],
        [48, 50, 52, 54, 56, 58, 60, 62],
        [56, 58, 60, 62, 64, 66, 68, 70]],

                            [[[[[24, 26, 28, 30, 32, 34, 36, 38],
        [32, 34, 36, 38, 40, 42, 44, 46],
        [40, 42, 44, 46, 48, 50, 52, 54],
        [48, 50, 52, 54, 56, 58, 60, 62],
        [56, 58, 60, 62, 64, 66, 68, 70],
        [64, 66, 68, 70, 72, 74, 76, 78]]])

La façon dont fonctionne la diffusion est que NumPy duplique l'avion dans B trois fois pour avoir un total de quatre, correspondant au nombre d'avions dans UNE. Il duplique également la ligne unique dans UNE cinq fois pour un total de six, correspondant au nombre de lignes dans B. Ensuite, il ajoute chaque élément dans le nouveau UNE tableau à son homologue au même emplacement dans B. Le résultat de chaque calcul apparaît à l'emplacement correspondant de la sortie.

Encore une fois, même si vous pouvez utiliser des mots tels que «plan», «ligne» et «colonne» pour décrire la façon dont les formes de cet exemple sont diffusées pour créer des formes tridimensionnelles correspondantes, les choses se compliquent à des dimensions plus élevées. Souvent, vous devrez simplement suivre les règles de diffusion et faire de nombreuses impressions pour vous assurer que tout fonctionne comme prévu.

La compréhension de la diffusion est une partie importante de la maîtrise des calculs vectorisés, et les calculs vectorisés sont le moyen d'écrire un code NumPy propre et idiomatique.

Indexage

L'indexation utilise plusieurs des mêmes idiomes que le code Python normal utilise. Vous pouvez utiliser des indices positifs ou négatifs pour indexer à partir de l'avant ou de l'arrière du tableau. Vous pouvez utiliser deux points (:) pour spécifier «le reste» ou «tout», et vous pouvez même utiliser deux deux points pour sauter des éléments comme avec les listes Python classiques.

Voici la différence: les tableaux NumPy utilisent des virgules entre les axes, vous pouvez donc indexer plusieurs axes dans un ensemble de crochets. Un exemple est le moyen le plus simple de montrer cela. Il est temps de confirmer le carré magique de Dürer!

Le carré numérique ci-dessous a des propriétés étonnantes. Si vous additionnez l'une des lignes, colonnes ou diagonales, vous obtiendrez le même nombre, 34. C'est également ce que vous obtiendrez si vous additionnez chacun des quatre quadrants, les quatre carrés du centre, les quatre coins carrés, ou les quatre carrés d'angle de l'une des grilles 3 × 3 contenues. Vous allez le prouver!

Entrez ce qui suit dans votre REPL:

Dans [1]: importer engourdi comme np

Dans [2]: carré = np.tableau([[[[
            ...:     [[[[16, 3, 2, 13],
            ...:     [[[[5, dix, 11, 8],
            ...:     [[[[9, 6, sept, 12],
            ...:     [[[[4, 15, 14, 1]
            ...: ])

Dans [3]: pour je dans intervalle(4):
            ...:     affirmer carré[:[:[:[: je].somme() == 34
            ...:     affirmer carré[[[[je, :].somme() == 34
            ...:

Dans [4]: affirmer carré[:[:[:[:2, :2].somme() == 34

Dans [5]: affirmer carré[[[[2:, :2].somme() == 34

Dans [6]: affirmer carré[:[:[:[:2, 2:].somme() == 34

Dans [7]: affirmer carré[[[[2:, 2:].somme() == 34

À l'intérieur de pour boucle, vous vérifiez que toutes les lignes et toutes les colonnes totalisent 34. Après cela, en utilisant l'indexation sélective, vous vérifiez que chacun des quadrants ajoute également jusqu'à 34.

Une dernière chose à noter est que vous pouvez prendre la somme de n'importe quel tableau pour additionner tous ses éléments globalement avec square.sum (). Cette méthode peut également prendre un axe argument pour faire une somme par axe à la place.

Masquage et filtrage

La sélection basée sur un index est excellente, mais que faire si vous souhaitez filtrer vos données en fonction de critères non uniformes ou non séquentiels plus complexes? C'est là que le concept d'un masque entre en jeu.

Un masque est un tableau qui a exactement la même forme que vos données, mais au lieu de vos valeurs, il contient des valeurs booléennes: soit Vrai ou Faux. Vous pouvez utiliser ce tableau de masques pour indexer votre tableau de données de manière non linéaire et complexe. Il retournera tous les éléments où le tableau booléen a un Vrai valeur.

Voici un exemple montrant le processus, d'abord au ralenti, puis comment il est généralement effectué, le tout sur une seule ligne:

Dans [1]: importer engourdi comme np

Dans [2]: Nombres = np.linspace(5, 50, 24, dtype=int).remodeler(4, -1)

Dans [3]: Nombres
En dehors[3]:
tableau ([[ 5, 6,  8, 10, 12, 14],
       [16, 18, 20, 22, 24, 26],
       [28, 30, 32, 34, 36, 38],
       [40, 42, 44, 46, 48, 50]])

Dans [4]: masque = Nombres % 4 == 0

Dans [5]: masque
En dehors[5]:
tableau ([[False, False,  True, False,  True, False],
       [ True, False,  True, False,  True, False],
       [ True, False,  True, False,  True, False],
       [ True, False,  True, False,  True, False]])

Dans [6]: Nombres[[[[masque]
En dehors[6]: tableau ([ 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48])

Dans [7]: par_four = Nombres[[[[Nombres % 4 == 0]

Dans [8]: par_four
En dehors[8]: tableau ([ 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48])

Vous verrez une explication des nouvelles astuces de création de tableau dans l'entrée 2 dans un instant, mais pour l'instant, concentrez-vous sur le cœur de l'exemple. Voici les parties importantes:

• Entrée 4 crée le masque en exécutant un calcul booléen vectorisé, en prenant chaque élément et en vérifiant s'il se divise uniformément par quatre. Cela renvoie un tableau de masque de la même forme avec les résultats élément par élément du calcul.
• Entrée 6 utilise ce masque pour indexer dans l'original Nombres tableau. Cela fait perdre au tableau sa forme d'origine, le réduisant à une dimension, mais vous obtenez toujours les données que vous recherchez.
• Entrée 7 fournit une sélection masquée idiomatique plus traditionnelle que vous pourriez voir dans la nature, avec un tableau de filtrage anonyme créé en ligne, à l'intérieur des crochets de sélection. Cette syntaxe est similaire à l'utilisation dans le langage de programmation R.

Pour en revenir à l'entrée 2, vous rencontrez trois nouveaux concepts:

1. En utilisant np.linspace () pour générer un tableau régulièrement espacé
2. Réglage du dtype d'une sortie
3. Remodeler un tableau avec -1

np.linspace () génère n nombres uniformément répartis entre un minimum et un maximum, ce qui est utile pour un échantillonnage uniformément réparti dans le traçage scientifique.

En raison du calcul particulier de cet exemple, il est plus facile d'avoir des entiers dans le Nombres tableau. Mais comme l'espace entre 5 et 50 ne se divise pas uniformément par 24, les nombres résultants seraient des nombres à virgule flottante. Vous spécifiez un dtype de int pour forcer la fonction à arrondir et vous donner des entiers entiers. Vous verrez une discussion plus détaillée sur les types de données plus tard.

Finalement, array.reshape () peut prendre -1 comme l'une de ses tailles de dimension. Cela signifie que NumPy devrait simplement déterminer la taille de cet axe particulier en fonction de la taille des autres axes. Dans ce cas, avec 24 valeurs et une taille de 4 dans l'axe 0, l'axe 1 se termine par une taille de 6.

Voici un autre exemple pour montrer la puissance du filtrage masqué. La distribution normale est une distribution de probabilité dans laquelle environ 95,45% des valeurs se produisent à l'intérieur de deux écarts-types de la moyenne.

Vous pouvez le vérifier avec un peu d’aide de NumPy’s Aléatoire module de génération de valeurs aléatoires:

Dans [1]: importer engourdi comme np

Dans [2]: de numpy.random importer default_rng

Dans [3]: rng = default_rng()

Dans [4]: valeurs = rng.standard_normal(10 000)

Dans [5]: valeurs[:[:[:[:5]
En dehors[5]: tableau ([977921085818361585253-3641365235[977921085818361585253-3641365235[977921085818361585253-3641365235[977921085818361585253-3641365235
                                                            -.1311344527, 1.286542056])

Dans [6]: std = valeurs.std()

Dans [7]: std
En dehors[7]: .9940375551073492

Dans [8]: filtré = valeurs[([([([(valeurs > -2 * std) & (valeurs < 2 * std)]

Dans [9]: filtré.Taille
En dehors[9]: 9565

Dans [10]: valeurs.Taille
En dehors[10]: 10 000

Dans [11]: filtré.Taille / valeurs.Taille
En dehors[11]: 0,9565

Ici, vous utilisez une syntaxe potentiellement étrange pour combiner des conditions de filtre: a binaire & opérateur. Pourquoi serait-ce le cas? C’est parce que NumPy désigne & et | comme opérateurs vectorisés par élément pour combiner des booléens. Si vous essayez de faire A et B, alors vous recevrez un avertissement indiquant que la valeur de vérité d'un tableau est étrange, car le et fonctionne sur la valeur de vérité de l'ensemble du tableau, pas élément par élément.

Transposition, tri et concaténation

D'autres manipulations, même si elles ne sont pas aussi courantes que l'indexation ou le filtrage, peuvent également être très pratiques selon la situation dans laquelle vous vous trouvez. Vous verrez quelques exemples dans cette section.

Voici transposer un tableau:

Dans [1]: importer engourdi comme np

Dans [2]: une = np.tableau([[[[
            ...:     [[[[1, 2],
            ...:     [[[[3, 4],
            ...:     [[[[5, 6],
            ...: ])

Dans [3]: une.T
En dehors[3]:
tableau ([[1, 3, 5],
       [2, 4, 6]])

Dans [4]: une.transposer()
En dehors[4]:
tableau ([[1, 3, 5],
       [2, 4, 6]])

Lorsque vous calculez la transposition d'un tableau, les indices de ligne et de colonne de chaque élément sont commutés. Article [0, 2], par exemple, devient item [2, 0]. Vous pouvez aussi utiliser à comme alias pour a.transpose ().

Le bloc de code suivant montre le tri, mais vous verrez également une technique de tri plus puissante dans la section à venir sur les données structurées:

Dans [1]: importer engourdi comme np

Dans [2]: Les données = np.tableau([[[[
            ...:     [[[[sept, 1, 4],
            ...:     [[[[8, 6, 5],
            ...:     [[[[1, 2, 3]
            ...: ])

Dans [3]: np.Trier(Les données)
En dehors[3]:
tableau ([[1, 4, 7],
       [5, 6, 8],
       [1, 2, 3]])

Dans [4]: np.Trier(Les données, axe=Aucun)
En dehors[4]: tableau ([1, 1, 2, 3, 4, 5, 6, 7, 8])

Dans [5]: np.Trier(Les données, axe=0)
En dehors[5]:
tableau ([[1, 1, 3],
       [7, 2, 4],
       [8, 6, 5]])

Omettre le axe L'argument sélectionne automatiquement la dernière dimension la plus interne, qui correspond aux lignes de cet exemple. En utilisant Aucun aplatit le tableau et effectue un tri global. Sinon, vous pouvez spécifier l'axe de votre choix. Dans la sortie 5, chaque colonne du tableau a toujours tous ses éléments, mais ils ont été triés de bas en haut dans cette colonne.

Enfin, voici un exemple de enchaînement. Tant qu'il y a un np.concatenate () fonction, il existe également un certain nombre de fonctions d'assistance qui sont parfois plus faciles à lire.

Voici quelques exemples:

Dans [1]: importer engourdi comme np

Dans [2]: une = np.tableau([[[[
            ...:     [[[[4, 8],
            ...:     [[[[6, 1]
            ...: ])

Dans [3]: b = np.tableau([[[[
            ...:     [[[[3, 5],
            ...:     [[[[sept, 2],
            ...: ])

Dans [4]: np.hstack((une, b))
En dehors[4]:
array([[4, 8, 3, 5],
       [6, 1, 7, 2]])

Dans [5]: np.vstack((b, une))
En dehors[5]:
array([[3, 5],
       [7, 2],
       [4, 8],
       [6, 1]])

Dans [6]: np.concatenate((une, b))
En dehors[6]:
array([[[[[4, 8],
       [6, 1],
       [3, 5],
       [7, 2]])

Dans [7]: np.concatenate((une, b), axis=None)
En dehors[7]: array([4, 8, 6, 1, 3, 5, 7, 2])

Inputs 4 and 5 show the slightly more intuitive functions hstack() et vstack(). Inputs 6 and 7 show the more generic concatenate(), first without an axis argument and then with axis=None. This flattening behavior is similar in form to what you just saw with sort().

One important stumbling block to note is that all these functions take a tuple of arrays as their first argument rather than a variable number of arguments as you might expect. You can tell because there’s an extra pair of parentheses.

Aggregating

Your last stop on this tour of functionality before diving into some more advanced topics and examples is aggregation. You’ve already seen quite a few aggregating methods, including .sum(), .max(), .mean(), and .std(). You can reference NumPy’s larger library of functions to see more. Many of the mathematical, financial, and statistical functions use aggregation to help you reduce the number of dimensions in your data.

Numerical Types: int, bool, float, and complex

Since most of your data science and numerical calculations will tend to involve numbers, they seem like the best place to start. There are essentially four numerical types in NumPy code, and each one can take a few different sizes.

The table below breaks down the details of these types:

These are just the types that map to existing Python types. NumPy also has types for the smaller-sized versions of each, like 8-, 16-, and 32-bit integers, 32-bit single-precision floating-point numbers, and 64-bit single-precision complex numbers. The documentation lists them in their entirety.

To specify the type when creating an array, you can provide a dtype argument:

Dans [1]: import numpy as np

Dans [2]: une = np.array([[[[1, 3, 5.5, 7,7, 9.2], dtype=np.single)

Dans [3]: une
En dehors[3]: array([1. , 3. , 5.5, 7.7, 9.2], dtype=float32)

Dans [4]: b = np.array([[[[1, 3, 5.5, 7,7, 9.2], dtype=np.uint8)

Dans [5]: b
En dehors[5]: array([1, 3, 5, 7, 9], dtype=uint8)

NumPy automatically converts your platform-independent type np.single to whatever fixed-size type your platform supports for that size. In this case, it uses np.float32. If your provided values don’t match the shape of the dtype you provided, then NumPy will either fix it for you or raise an error.

String Types: Sized Unicode

Strings behave a little strangely in NumPy code because NumPy needs to know how many bytes to expect, which isn’t usually a factor in Python programming. Luckily, NumPy does a pretty good job at taking care of less complex cases for you:

Dans [1]: import numpy as np

Dans [2]: names = np.array([[[["bob", "amy", "han"], dtype=str)

Dans [3]: names
En dehors[3]: array(['bob', 'amy', 'han'], dtype='<U3')

Dans [4]: names.itemsize
En dehors[4]: 12

Dans [5]: names = np.array([[[["bob", "amy", "han"])

Dans [6]: names
En dehors[6]: array(['bob', 'amy', 'han'], dtype='<U3')

Dans [7]: more_names = np.array([[[["bobo", "jehosephat"])

Dans [8]: np.concatenate((names, more_names))
En dehors[8]: array(['bob', 'amy', 'han', 'bobo', 'jehosephat'], dtype='<U10')

In input 2, you provide a dtype of Python’s built-in str type, but in output 3, it’s been converted into a little-endian Unicode string of size 3. When you check the size of a given item in input 4, you see that they’re each 12 bytes: three 4-byte Unicode characters.

When you combine that with an array that has a larger item to create a new array in input 8, NumPy helpfully figures out how big the new array’s items need to be and grows them all to size <U10.

But here’s what happens when you try to modify one of the slots with a value larger than the capacity of the dtype:

Dans [9]: names[[[[2] = "jamima"

Dans [10]: names
En dehors[10]: array(['bob', 'amy', 'jam'], dtype='<U3')

It doesn’t work as expected and truncates your value instead. If you already have an array, then NumPy’s automatic size detection won’t work for you. You get three characters and that’s it. The rest get lost in the void.

This is all to say that, in general, NumPy has your back when you’re working with strings, but you should always keep an eye on the size of your elements and make sure you have enough space when modifying or changing arrays in place.

Structured Arrays

Originally, you learned that array items all have to be the same data type, but that wasn’t entirely correct. NumPy has a special kind of array, called a record array ou structured array, with which you can specify a type and, optionally, a name on a per-column basis. This makes sorting and filtering even more powerful, and it can feel similar to working with data in Excel, CSVs, or relational databases.

Here’s a quick example to show them off a little:

Dans [1]: import numpy as np

Dans [2]: Les données = np.array([[[[
            ...:     ("joe", 32, 6),
            ...:     ("mary", 15, 20),
            ...:     ("felipe", 80, 100),
            ...:     ("beyonce", 38, 9001),
            ...: ], dtype=[([([([("name", str, dix), ("age", int), ("power", int)])

Dans [3]: Les données[[[[0]
En dehors[3]: ('joe', 32, 6)

Dans [4]: Les données[[[["name"]
En dehors[4]: array(['joe', 'mary', 'felipe', 'beyonce'], dtype='<U10')

Dans [5]: Les données[[[[Les données[[[["power"] > 9000][[[["name"]
En dehors[5]: array(['beyonce'], dtype='<U10')

In input 2, you create an array, except each item is a tuple with a name, an age, and a power level. For the dtype, you actually provide a list of tuples with the information about each field: name is a 10-character Unicode field, and both age et power are standard 4-byte or 8-byte integers.

In input 3, you can see that the rows, known as records, are still accessible using the index.

In input 4, you see a new syntax for accessing an entire column, or field.

Finally, in input 5, you see a super-powerful combination of mask-based filtering based on a field and field-based selection. Notice how it’s not that much different to read the following SQL query:

SELECT name FROM Les données
WHERE power > 9000;

In both cases, the result is a list of names where the power level is over 9000.

You can even add in ORDER BY functionality by making use of np.sort():

Dans [6]: np.sort(Les données[[[[Les données[[[["age"] > 20], order="power")[[[["name"]
En dehors[6]: array(['joe', 'felipe', 'beyonce'], dtype='<U10')

This sorts the data by power before retrieving it, which rounds out your selection of NumPy tools for selecting, filtering, and sorting items just like you might in SQL!

More on Data Types

This section of the tutorial was designed to get you just enough knowledge to be productive with NumPy’s data types, understand a little of how things work under the hood, and recognize some common pitfalls. It’s certainly not an exhaustive guide. The NumPy documentation on ndarrays has tons more resources.

There’s also a lot more information on dtype objects, including the different ways to construct, customize, and optimize them and how to make them more robust for all your data-handling needs. If you run into trouble and your data isn’t loading into arrays exactly how you expected, then that’s a good place to start.

Lastly, the NumPy recarray is a powerful object in its own right, and you’ve really only scratched the surface of the capabilities of structured datasets. It’s definitely worth reading through the recarray documentation as well as the documentation for the other specialized array subclasses that NumPy provides.

pandas

pandas is a library that takes the concept of structured arrays and builds it out with tons of convenience methods, developer-experience improvements, and better automation. If you need to import data from basically anywhere, clean it, reshape it, polish it, and then export it into basically any format, then pandas is the library for you. It’s likely that at some point, you’ll import pandas as pd at the same time you import numpy as np.

The pandas documentation has a speedy tutorial filled with concrete examples called 10 Minutes to pandas. It’s a great resource that you can use to get some quick, hands-on practice.

scikit-learn

If your goals lie more in the direction of machine learning, then scikit-learn is the next step. Given enough data, you can do classification, regression, clustering, and more in just a few lines.

If you’re already comfortable with the math, then the scikit-learn documentation has a great list of tutorials to get you up and running in Python. If not, then the Math for Data Science Learning Path is a good place to start. Additionally, there’s also an entire learning path for machine learning.

It’s important for you to understand at least the basics of the mathematics behind the algorithms rather than just importing them and running with it. Bias in machine learning models is a huge ethical, social, and political issue.

Throwing data at models without a considering how to address the bias is a great way to get into trouble and negatively impact people’s lives. Doing some research and learning how to predict where bias might occur is a good start in the right direction.

Matplotlib

No matter what you’re doing with your data, at some point you’ll need to communicate your results to other humans, and Matplotlib is one of the main libraries for making that happen. For an introduction, check out Plotting with Matplotlib. In the next section, you’ll get some hands-on practice with Matplotlib, but you’ll use it for image manipulation rather than for making plots.