Python - Notes d'étude de la bibliothèque Numpy

ndarray

• Nadrray est un objet de tableau à N dimensions, un conteneur rapide et flexible pour les grands ensembles de données
• Vous pouvez utiliser ce tableau (ndarray) pour effectuer des opérations mathématiques sur tout le bloc de données

Importez le code de la bibliothèque Nump

import numpy as np

Générer des données aléatoires

data = np.random.randn(2, 3)

–Numpy.random.randn ()

• La fonction randn renvoie un échantillon ou un ensemble d'échantillons avec une distribution normale standard
• La distribution normale standard est également appelée distribution u. Il s'agit d'une distribution normale avec 0 comme moyenne et 1 comme écart type, notée N (0, 1)

--Dn signifie chaque dimension, randn (2, 3) signifie retourner un tableau avec 2 lignes et 3 colonnes

Les tableaux peuvent effectuer des opérations mathématiques

• Multipliez chaque élément du tableau par 10

data * 10

• Ajoutez deux tableaux, chaque élément du tableau est ajouté en conséquence

data + data

Numpy est un conteneur multidimensionnel universel de données isomorphes, dans lequel tous les éléments doivent être du même type.
Chaque tableau a

• shape (un tuple représentant la taille de chaque dimension)
• dtype (un objet utilisé pour décrire le type de données d'un tableau)

Jetez un œil à la forme et au type du tableau de données

data.shape

On peut voir que les données sont un tableau avec 2 lignes et 3 colonnes

data.dtype

On peut voir que le type de données du tableau de données est 'float64'

Créer ndarray

La fonction array peut être utilisée pour créer un tableau ndarray. Elle accepte tous les objets série (y compris les autres tableaux).
Prenons la conversion d'une liste comme exemple:

data1 = [6, 7.5, 8, 0, 1]
arr1 = np.array(data1)
arr1

Vous pouvez voir que la liste data1 est convertie dans le tableau arr1

Si la liste est composée d'un ensemble de listes de longueur égale, la fonction de tableau la convertira en un tableau multidimensionnel

data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)
arr2

On peut voir que la liste composée de deux listes est convertie en un tableau à 2 dimensions

Nous pouvons utiliser les attributs ndim et shape pour vérifier

arr2.ndim

-ndim renvoie la dimension du tableau, un seul nombre est renvoyé, qui représente la dimension du tableau

arr2.shape

-S'il n'y a pas d'instructions spéciales, np.array sélectionnera le type de données le plus correspondant pour les données à créer
-comme arr1, arr2 dans l'exemple ci-dessus, nous pouvons voir le type de données créé

, s'il y a des décimales dans la liste, le tableau créé par array Le type de données est à virgule flottante ->
si la liste de 'float64' est composée de nombres entiers, alors le type de données du tableau créé par array est integer -> 'int32'

La méthode --np.zeros () peut créer un tableau de tous les 0 avec une longueur ou une forme spécifiée.
Si un nombre 10 est passé, un tableau unidimensionnel de 10 '0 sera créé par défaut

np.zeros(10)

Le type de données du tableau créé est en virgule flottante

np.zeros(10).dtype

Passez un tuple représentant la forme, vous pouvez créer un tableau multidimensionnel,
comme créer un tableau à deux dimensions de tous les '0 avec 3 lignes et 6 colonnes

np.zeros((3, 6))

- La méthode NP.empty () spécifie un tableau non initialisé de longueur ou de forme, ou vous pouvez passer un tuple pour créer un tableau multidimensionnel,
comme la création d'un tableau non initialisé en trois dimensions (2 * 3 lignes et 2 colonnes)

np.empty((2, 3, 2))

Remarque: l'idée que np.empty renvoie un tableau de tous les 0 n'est pas sûre. Dans de nombreux cas, elle renvoie des valeurs de garbage non initialisées.

np.arange ()

- Le tableau dans numpy est la version tableau de la fonction intégrée de python "gamme". Le
paramètre N est passé, ce qui signifie générer un tableau d'entiers de 0 à (N-1)

Par exemple, créez un tableau d'entiers de 0 à 14

np.arange(15)

np.arange(15).dtype

Remarque: Numpy se concentre sur les calculs numériques. S'il n'est pas spécifié, les types de données sont essentiellement "float64" (nombres à virgule flottante)

Voici quelques fonctions de création de tableaux couramment utilisées, qui sont fréquemment utilisées

• Array: Convertissez les données en ndarray (tableau multidimensionnel), si dtype n'est pas spécifié, il correspondra au type de données le plus approprié pour les données source par défaut
• asarry: Convertit les données en ndarray (tableau multidimensionnel). La différence entre celui-ci et le tableau est -> Lorsque les données source sont ndarray, array
  copiera une copie de ndarray, mais pas asarray
• arange: similaire à la plage de fonctions intégrées de python, mais arange renvoie un ndarry et la plage intégrée renvoie une liste
• ones: Créez un tableau de tous les '1' en fonction de la forme et du type spécifiés, la valeur par défaut est 'flottant64'
• ones_like: prenez un autre tableau comme paramètre (obtenez la forme du tableau) et créez un tableau de tous les '1 en fonction de la forme du paramètre
• zeros, zeros_like: similaire à uns et ones_like, mais crée un tableau de tous les '0'
• empty, empty_like: similaire à ones et ones_like, mais il alloue uniquement de l'espace mémoire, mais ne remplit aucune valeur (toutes les valeurs de garbage non initialisées sont créées)
• full: utilisez toutes les valeurs de la valeur de remplissage pour créer un tableau basé sur la forme et le dtype spécifiés (simulez un ensemble de fill_value ici)
• full_like: crée un tableau de la même forme avec la forme d'un autre tableau, la valeur du tableau est fill_value
• oeil: entrez le paramètre N, créez une matrice d'identité carrée N * N (la diagonale est 1, le reste est 0), le type de tableau est à virgule flottante
• identité: identique à np.eye ()

dtype

-Dtype contient les informations nécessaires pour interpréter une partie de la mémoire de ndarry comme un type de données spécifique

Types de données Numpy courants

• int8: code de type: i1 -> entier signé 8 bits (1 octet)
• uint8: code de type: u1 -> entier 8 bits (1 octet) non signé
• int16: code de type: i2 -> entier 16 bits (2 octets) signé
• uint16: Code de type: u2 -> entier 16 bits (2 octets) non signé
• int32: code de type: i4 -> entier signé 32 bits (4 octets)
• uint32: code de type: u4 -> entier 32 bits (4 octets) non signé
• int64: code de type: i8 -> entier signé 64 bits (8 octets)
• uint64: code de type: u8 -> entier 64 bits (8 octets) non signé
• float16: Code de type: f2 -> nombre à virgule flottante demi-précision
• float32: Code de type: f4 ou f -> nombre à virgule flottante simple précision standard (compatible avec C float)
• float64: Code de type: f8 ou d -> nombre à virgule flottante double précision standard (compatible avec les objets C double et Python float)
• float128: Code de type: f16 ou g -> nombre à virgule flottante de précision étendue
• complex64: code de type: c8 -> un nombre complexe représenté par deux nombres à virgule flottante 32 bits
• complex128: code de type: c16 -> un nombre complexe représenté par deux nombres à virgule flottante 64 bits
• complex256: code de type: c32 -> un nombre complexe représenté par deux nombres à virgule flottante de 128 bits
• booléen: Tapez le code :? -> Type booléen stockant Vrai et Faux
• objet: code de type: O -> type d'objet Python
• string_: code de type: S -> type de chaîne de longueur fixe (1 octet par caractère), par exemple, pour créer une chaîne de longueur 10, vous devez utiliser S10
• unicode_: code de type: U -> type unicode de longueur fixe (le nombre d'octets est déterminé par la plateforme)

- Vous pouvez convertir explicitement un tableau d'un dtype vers un autre dtype en utilisant la méthode astype de ndarray.
Supposons qu'il existe un tableau d'entiers arr

arr = np.array([1, 2, 3, 4, 5])

Convertir arr en virgule flottante

float_arr = arr.astype(np.float64)

Si vous convertissez un nombre à virgule flottante en nombre entier, la partie fractionnaire sera tronquée et supprimée.
Par exemple, il existe un tableau à virgule flottante arr2

arr2 = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])

Convertir en entier

int_arr2 = arr2.astype(np.int32)

Vous pouvez voir que le nouveau tableau int_arr2 intercepte et supprime la partie décimale du tableau d'origine

Vous pouvez également utiliser un type pour convertir un tableau de chaînes en une forme numérique.
Supposons qu'il existe un tableau de chaînes numeric_strings

numeric_strings = np.array(['1.25', '-9.6', '42'], dtype = np.string_)

• Remarque: lorsque vous utilisez np.string_ type, faites attention à la longueur de la chaîne, car la taille des données de la chaîne de numpy est fixe et aucune erreur ne sera signalée lors de l'interception.
• Si pendant le processus de conversion, la conversion de la chaîne -> valeur numérique échoue (par exemple, "un" ne peut pas être converti en valeur numérique 1, une ValueError sera déclenchée

-Nous pouvons également transmettre le dtype d'un tableau comme paramètre à la méthode astype.
Supposons qu'il existe un tableau d'entiers int_array et un tableau à virgule flottante calibres

int_array = np.arange(10)
calibers = np.array([.22, .270, .357, .380, .44, .50], dtype = np.float64)

Si vous souhaitez convertir int_array dans le même tableau à virgule flottante que les calibres, vous pouvez passer le dtype des calibres dans le paramètre de la méthode astype

int_float = int_array.astype(calibers.dtype)
int_float.dtype

-Vous pouvez également utiliser le code de type du type de données pour représenter dtype

empty_unit32 = np.empty(8, dtype = 'u4')

Opérations de tableau Numpy

• Toute opération arithmétique entre des tableaux de taille égale appliquera l'opération au niveau élément

Créer un tableau à deux dimensions arr avec 2 lignes et 3 colonnes

arr = np.array([[1., 2., 3.], [4., 5., 6.]])
arr.shape

Multipliez entre des tableaux de taille égale et les éléments sont multipliés en conséquence

arr * arr

Soustraire entre des tableaux de taille égale et les éléments sont soustraits en conséquence

arr - arr

Les opérations arithmétiques entre les tableaux et les scalaires propageront les opérations de valeurs scalaires à chaque élément

1 / arr

La comparaison entre des tableaux de même taille produira un tableau booléen.
Créons un tableau bidimensionnel arr avec la même taille que arr

arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])

- Comparez arr et arr2

arr2 > arr

Vous pouvez voir qu'un tableau booléen de la même taille est généré et que chaque élément du tableau est une comparaison de arr et arr2.

Indexation et découpage de base

Tranche de tableau à une dimension

• En surface, le découpage de tableau unidimensionnel est similaire à la fonction de découpage de liste de Python

Créer un tableau d'entiers 0-9 arr

arr = np.arange(10)

• Prenez le sixième élément dans arr

arr[5]

• Prenez les 6ème à 8ème éléments dans arr, fermez avant de trancher puis ouvrez

arr[5: 8]

• Vous pouvez attribuer une valeur à la partie découpée et le tableau source est modifié sur place.
  Si j'attribue le 6e au 8e nombre d'arr avec '12'

arr[5: 8] = 12

Comme vous pouvez le voir, le tableau arr est modifié in situ
- donc la différence la plus importante entre la tranche de tableau et la tranche de liste python est: la tranche de tableau est une vue des données d'origine, ce qui signifie que les données ne seront pas copiées, et toute modification sur la vue reflétera directement Sur la baie source

Par exemple, créez une tranche de arr_slice

arr_slice = arr[5: 8]

• Remarque: Si nous modifions la valeur de arr_slice, le changement sera reflété dans le tableau d'origine arr

Par exemple, attribuez le deuxième nombre d'arr_slice à «12345»

arr_slice[1] = 12345

Comme vous pouvez le voir, les données du tableau source sont également modifiées

- Slice [:] signifie couper toutes les valeurs du tableau. Par
exemple, nous attribuons une valeur de «64» à chaque tuple dans arr_slice

arr_slice[:] = 64

On peut voir que chaque élément de arr_slice se voit attribuer une valeur de '64'

• La raison pour laquelle l'opération ci-dessus est différente du découpage natif de Python est que Numpy est conçu pour gérer le Big Data. Si les données sont copiées et copiées, cela exercera une pression considérable sur les performances et la mémoire.
• Bien sûr, si vous souhaitez obtenir une copie de tranche du ndarray (tableau) au lieu de la vue, vous pouvez ajouter une méthode copy () après la tranche

Par exemple, nous voulons obtenir une copie de tranche des 6e à 8e éléments de arr et l'affecter avec '6'

arr3 = arr[5: 8].copy()
arr3[:] = 6

Comme vous pouvez le voir, opérer sur la copie de la tranche de tableau n'affecte pas le tableau source

Tableau bidimensionnel

-Dans un tableau à deux dimensions, les éléments à chaque position d'index ne sont plus des scalaires comme des tableaux à une dimension, mais des tableaux à une dimension

Par exemple, créez un tableau à deux dimensions arr2d

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Prenez le troisième élément de arr2d

arr2d[2]

Le résultat est un tableau unidimensionnel

- Si vous souhaitez obtenir un seul élément scalaire, vous pouvez accéder de manière récursive aux éléments de grande dimension. Par
exemple, je souhaite obtenir le troisième scalaire du premier tableau unidimensionnel d'un tableau à deux dimensions

arr2d[0, 2]

L'idée de récursivité hiérarchique est utilisée ici

Tableaux multidimensionnels

- Le principe des tableaux multidimensionnels est similaire à celui des tableaux bidimensionnels

Nous créons un tableau tridimensionnel 2 * 2 * 3 arr3d

arr3d = np.array([[[1, 2, 3], [4, 5, 6]],
                 [[7, 8, 9], [10, 11, 12]]])

• Si vous coupez arr3d et passez un paramètre scalaire, alors ce qui est renvoyé est un tableau bidimensionnel réduit d'une dimension

Par exemple, je veux obtenir le premier tableau bidimensionnel de arr3d

arr3d[0]

Comme vous pouvez le voir, ce qui est renvoyé est un tableau bidimensionnel 2 * 3.
Au fur et à mesure que le paramètre de tranche augmente, la dimension du tableau renvoyé diminue jusqu'à ce qu'une valeur scalaire soit renvoyée.

- Les valeurs scalaires et les tableaux peuvent être affectés à arr3d [0]

Avant d'afficher l'affectation, nous créons d'abord une copie de arr3d [0] old_values ​​afin de restaurer le tableau source

old_values = arr3d[0].copy()

Ensuite, nous affectons le premier tableau bidimensionnel de arr3d ce tableau tridimensionnel à 42

arr3d[0] = 42

Comme vous pouvez le voir, chaque élément du premier tableau bidimensionnel obtenu par découpage se voit attribuer une valeur de 42

Nous utilisons la copie originale pour restaurer le tableau source

arr3d[0] = old_values

• Notez que s'il n'y a pas de traitement spécial, la tranche renvoie une vue du tableau source, et la modification de la tranche affectera la valeur du tableau source

Index de tranche

- La syntaxe de découpage de ndarray est similaire
à celle des objets unidimensionnels tels que les listes Python. Regardez le tableau unidimensionnel précédent arr, nous prenons le deuxième au sixième éléments de arr

arr[1:6]

Pour un tableau bidimensionnel 3 * 3 arr2d, la tranche sélectionne les éléments le long d'un axe, le 0e axe est la ligne et le premier axe est la colonne.
Nous sélectionnons les deux premières lignes du tableau bidimensionnel

arr2d[:2]

On voit ici que arr2d [: 2] est une manière simple d'écrire arr2d [0: 2], ce qui signifie que les deux premières lignes de arr2d sont sélectionnées (front fermé puis ouvert)

-Il est également possible de transmettre plusieurs tranches à la fois. Par exemple, nous devons sélectionner toutes les données après la deuxième colonne dans les deux premières lignes du tableau arr2d

arr2d[ :2, 1: ]

• En mélangeant des index entiers et des tranches, vous pouvez obtenir des tranches de faible dimension.
  Par exemple, je souhaite sélectionner les deux premières colonnes de la deuxième ligne.

arr2d[1,  :2]

Nous obtenons un tableau unidimensionnel de dimensions inférieures

• Remarque: un simple deux-points indique que tout l'axe est sélectionné

• Bien sûr, l'opération d'affectation de la tranche sera également étendue à l'ensemble de la sélection, car la tranche est la vue après le traitement du tableau source, et le tableau source sera affecté par le changement de la tranche

Index booléen

- Supposons que nous ayons un tableau de données pour stocker les données et un tableau de noms pour stocker les noms (contenant des doublons)

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

Nous utilisons la fonction randn dans numpy.random pour générer une distribution normale standard avec 7 lignes et 4 colonnes de données de tableau aléatoire

data = np.random.randn(7, 4)

• Supposons que chaque nom du tableau names correspond à chaque ligne de la valeur de données.
  Nous voulons sélectionner toutes les lignes correspondant au nom de "Bob"

- Voyons quels noms dans les noms sont "Bob"

names == 'Bob'

• Ici, vous devez utiliser le signe '==' au lieu du signe '=', sinon vous attribuerez 'Bob' à chaque élément dans les noms
• On peut voir qu'un tableau booléen unidimensionnel est généré et que l'élément avec l'élément 'Bob' renvoie True, sinon c'est False

-Ensuite, nous passons le tableau booléen retourné en tant qu'index dans les données

data[names == 'Bob']

Il n'est pas difficile de trouver que les lignes correspondant à 'Bob' dans les données ont été sélectionnées

• Remarque: La longueur du tableau booléen doit être la même que la longueur de l'axe indexé. Si la longueur est incohérente, une erreur se produit.

-Bien sûr, vous pouvez également indexer plus d'axes, comme l'ajout d'un index de colonne, je veux obtenir les données après la deuxième colonne de la ligne correspondant à 'Bob' dans les données

data[names == 'Bob', 2: ]

- Si vous souhaitez sélectionner une valeur autre que 'Bob', vous pouvez utiliser le signe d'inégalité '! =' Ou '~' pour annuler

data[names != 'Bob']

En conséquence, les lignes restantes à l'exception de la ligne correspondant à Bob sont sélectionnées

- Nous utilisons souvent l'opérateur '~' pour effectuer une inversion conditionnelle. Par
exemple, nous passons d'abord le tableau booléen de 'Bob' à un objet cond

cond = names == 'Bob'

Utilisez ensuite l'opérateur ~ pour inverser l'objet dans l'index des données

data[~cond]

En conséquence, les lignes restantes à l'exception de la ligne correspondant à Bob sont également sélectionnées

-Si nous voulons ajouter des conditions de jugement, nous pouvons utiliser & (et), | (ou), et d'autres opérateurs arithmétiques booléens (vous ne pouvez pas utiliser les mots-clés et et ou en Python). Par
exemple, je veux sélectionner'Bob en même temps Les lignes correspondant aux deux noms de 'et' Will 'dans les données

mask = (names == 'Bob') | (names == 'Will')

data[mask]

En conséquence, les lignes correspondant à Bob et Will sont sélectionnées

• Remarque: la sélection de données dans le tableau par index booléen créera toujours une vue des données

- Nous définissons souvent des valeurs via des tableaux booléens. Par
exemple, définissez toutes les valeurs négatives des données sur 0

data[data < 0] = 0

-Vous pouvez également définir la valeur d'une ligne ou d'une colonne entière via un tableau booléen unidimensionnel

data[names != 'Joe'] = 7

Comme vous pouvez le voir, les données correspondant aux éléments de la ligne dont le nom est «Joe» reçoivent toutes la valeur 7

Index de fantaisie

• L'indexation fantaisie fait référence à: l'indexation avec des tableaux d'entiers

- Supposons qu'il y ait un tableau 8 * 4 arr

arr = np.empty((8, 4))

Ce tableau sert uniquement à créer de l'espace et contient des valeurs de garbage non initialisées

-Maintenant, nous remplissons ce tableau avec une boucle for

for i in range(8):
    arr[i] = i

Nous pouvons passer une liste d'entiers dans un ordre spécifié ou sélectionner un sous-ensemble du tableau

arr[[4, 3, 0, 6]]

Transposition de tableau et conversion d'axe

• La transposition est similaire au remodelage de tableau
• Transpose n'effectue aucune opération de copie et renvoie une vue des données source
• Le tableau a un attribut spécial T pour la transposition

Créer un tableau à deux dimensions avec 3 lignes et 5 colonnes

arr = np.arange(15).reshape((3, 5))

Transposer avec l'attribut T

arr.T

• Lors de l'exécution de calculs matriciels (comme le calcul du produit interne d'une matrice), la transposition est souvent nécessaire
• Pour calculer le produit interne de la matrice, nous pouvons utiliser la fonction dot dans numpy
• En fait, dot () renvoie le produit scalaire de deux tableaux

- Nous créons un tableau à deux dimensions et essayons de calculer le produit interne de celui-ci et son tableau transposé

arr = np.random.randn(6, 3)

Calculer le produit intérieur

np.dot(arr, arr.T)

-Comme pour la transposition d'un tableau à trois chiffres, un concept doit être introduit ici: la transposition nécessite un tuple composé de nombres d'axes.
Par exemple, créez un tableau tridimensionnel 2 * 2 * 4

arr = np.arange(16).reshape((2, 2, 4))

• Numérotez les trois axes du tableau tridimensionnel: 0, 1, 2 J'imagine la longueur (0), la largeur (1) et la hauteur (2) d'un cuboïde
• Lorsqu'elle est transposée, elle équivaut à la rotation horizontale du cuboïde de 90 degrés, et les valeurs de longueur et de largeur sont subjectivement comprises comme un échange: la longueur d'origine devient largeur et la largeur devient longueur, donc la longueur, la largeur et la hauteur du cuboïde transposé correspondent à Les numéros d'axe du cuboïde d'origine sont 1 (largeur), 0 (longueur), 2 (hauteur)

arr.transpose((1, 0, 2))

- Parlons de la fonction de transposition dans numpy. Les paramètres de transposition peuvent être compris comme les étiquettes d'axe du tableau

• Pour les tableaux à une dimension, numpy.transpose () ne fonctionne pas car il n'y a qu'un seul axe
• L'opération de transposition sur le tableau bidimensionnel est l'opération de transposition sur le tableau d'origine, et l'étiquette d'axe est convertie de (0, 1) à (1, 0)
• Pour un tableau en trois dimensions, transposer transformera deux des trois axes (voir comment vous définissez cette transposition)

-Il existe également une méthode swapaxes dans ndarray, qui permet d'échanger des axes.
Par exemple, je souhaite échanger les deuxième et troisième axes d'un tableau en trois dimensions

arr.swapaxes(1, 2)

• La méthode swapaxes est en fait une manière différente de transposer, ce qui est très pratique
• Il convient également de noter que la méthode swapaxes n'effectue pas d'opération de copie et renvoie une vue des données source