[PYTHON] Augmentez la "puissance numpy" avec [100 exercices numpy] (11e à 20e questions)
Augmentez la "puissance numpy" avec [100 exercices numpy](1re à 10e questions) Dans la continuité de l'article précédent, je vais résoudre les 11e à 20e questions.
- Create a 3x3 identity matrix (★☆☆)
** "Créer une matrice d'unité 3x3" **
- Matrice d'identité = matrice unitaire
Une matrice unitaire de n × n peut être générée par np.eye (n).
100_Numpy_exercises.ipynb-(11)answer
Z = np.eye(3)
print(Z)
Résultat d'exécution
100_Numpy_exercises.ipynb-(11)output
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
- Create a 3x3x3 array with random values (★☆☆)
** "Créer un tableau 3x3x3 (les éléments sont aléatoires)" **
Utilisez le module numpy.random pour générer des nombres aléatoires.
100_Numpy_exercises.ipynb-(12)answer
Z = np.random.rand(3,3,3) #Nombre aléatoire dans un tableau 3x3x3(0.0 ou plus 1.Moins de 0)
print(Z)
Résultat d'exécution
100_Numpy_exercises.ipynb-(12)output
[[[0.44518095 0.00924118 0.59004146]
[0.12450099 0.91674964 0.77679575]
[0.28061072 0.03625354 0.87043565]]
[[0.76171958 0.39143584 0.02266029]
[0.51873782 0.60923224 0.69941338]
[0.41821728 0.65331316 0.74005185]]
[[0.25365995 0.45885229 0.41108347]
[0.74013277 0.44224959 0.39538442]
[0.27518178 0.50242514 0.54273645]]]
Si vous souhaitez créer un tableau avec des nombres aléatoires entiers, utilisez numpy.random.randint ().
Spécifiez l'argument sous la forme numpy.random.randint (faible, élevé, taille). → Générer un tableau avec la taille spécifiée dans size avec un nombre aléatoire entier supérieur ou égal à faible et inférieur à élevé.
100_Numpy_exercises.ipynb-(12)answer
Z = np.random.randint(1,10,(3,3,3)) #Nombre aléatoire dans un tableau 3x3x3(Un entier supérieur ou égal à 1 et inférieur à 10.)
print(Z)
Résultat d'exécution
100_Numpy_exercises.ipynb-(12)output
[[[4 2 8]
[2 5 9]
[9 4 6]]
[[6 1 8]
[1 6 9]
[5 3 5]]
[[8 9 8]
[8 9 4]
[7 8 4]]]
- Create a 10x10 array with random values and find the minimum and maximum values (★☆☆)
** "Générer un tableau 10x10 avec des nombres aléatoires et trouver les valeurs minimales et maximales de l'élément" **
La génération aléatoire dans la première moitié est un examen de la question précédente. Le problème est la seconde moitié. Le minimum et le maximum du tableau peuvent être affichés par les fonctions min () et max (). C'est facile à comprendre.
100_Numpy_exercises.ipynb-(13)answer
Z = np.random.rand(10,10)
print(Z)
print(Z.min())
print(Z.max())
Résultat d'exécution
100_Numpy_exercises.ipynb-(13)output
[[0.52234883 0.04961266 0.26979588 0.35807264 0.58767559 0.66650289
0.51751858 0.00749977 0.64916673 0.52928179]
[0.84590062 0.475141 0.98199741 0.85117845 0.07182633 0.85569791
0.68031337 0.39577058 0.3102539 0.05988267]
[0.1908481 0.44464734 0.42211624 0.33883119 0.47234289 0.88443684
0.67840264 0.11499548 0.01561011 0.62472268]
[0.68165249 0.56003177 0.69289739 0.01834723 0.82186756 0.33528515
0.33715765 0.89662065 0.91279419 0.95973881]
[0.16768925 0.88251896 0.7545505 0.80567805 0.0875194 0.86998789
0.42720398 0.73700043 0.95089544 0.87874673]
[0.61277308 0.20511706 0.7039127 0.55107676 0.00495881 0.93791274
0.5540698 0.17465328 0.17021889 0.75724567]
[0.20103278 0.0402996 0.86112665 0.22460515 0.49205103 0.67606385
0.97352361 0.48226577 0.1698369 0.75163188]
[0.08707084 0.94483062 0.82773455 0.849915 0.54699492 0.63773099
0.88614943 0.839312 0.2898842 0.49742767]
[0.50516571 0.25980059 0.78911141 0.17191684 0.41938205 0.98415545
0.22282797 0.06791284 0.44208603 0.30956802]
[0.49319972 0.09882225 0.08468636 0.64297834 0.57264345 0.49475321
0.0089241 0.28765751 0.84352742 0.962471 ]]
0.004958805565047131
0.9841554497271033
- Create a random vector of size 30 and find the mean value (★☆☆)
** "Créez un vecteur d'une taille de 30 et trouvez la valeur moyenne" **
Utilisez mean () pour trouver la valeur moyenne du tableau. C'est également la même chose.
100_Numpy_exercises.ipynb-(14)answer
Z = np.random.rand(30)
print(Z)
print(Z.mean())
Résultat d'exécution
100_Numpy_exercises.ipynb-(14)output
[0.71731749 0.27092985 0.47882913 0.94756227 0.35222887 0.45151348
0.83705811 0.66280134 0.43406269 0.53061543 0.88052437 0.93703825
0.02288098 0.4235356 0.69145184 0.97566151 0.60787705 0.15327448
0.85466264 0.8320094 0.31804771 0.43561608 0.8271854 0.57419325
0.83537801 0.33995759 0.92256564 0.40740555 0.70334292 0.13671002]
0.5854078986104199
- Create a 2d array with 1 on the border and 0 inside (★☆☆)
** "Créer un tableau à deux dimensions avec une limite de 1 et un intérieur de 0" **
Je pense qu'il y a plusieurs façons de le faire, mais il semble facile de créer un tableau de tous les "1" et de réécrire l'intérieur en "0". Pour réécrire l'intérieur avec "0", spécifiez la plage en utilisant des tranches. Faisons-le avec un tableau 10x10.
100_Numpy_exercises.ipynb-(15)answer
Z = np.ones((10,10))
Z[1:-1,1:-1]=0
print(Z)
Résultat d'exécution
100_Numpy_exercises.ipynb-(15)output
array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])
- How to add a border (filled with 0's) around an existing array? (★☆☆)
** "Comment ajouter 0 éléments autour d'un tableau existant?" 』**
C'est un peu inquiétant. Jetons un coup d'œil à l'indice.
hint: np.pad
Il semble bon d'utiliser une fonction appelée np.pad (). Ce coussin est un rembourrage. Une fonction qui vous permet d'incorporer un autre élément autour d'un tableau.
Par exemple, disons que vous avez un tableau unidimensionnel avec ʻa = [1,2,3] `. Si vous voulez en remplir un avant et après ce tableau avec 0,
print(np.pad(a, [1,1], mode="constant"))
ça ira.
Résultat d'exécution
[0, 1, 2, 3, 0]
numpy.pad(array, pad_width, mode=xxx)
tableau: tableau existant pad_width: combien de minutes avant et après le tableau doit être rempli. Spécifiez comme (before_n, after_n). Si le recto et le verso sont identiques, vous pouvez le spécifier comme n. mode: quelle valeur remplir. Si "constant" est spécifié, il sera rempli avec une constante (la valeur par défaut est 0). Si vous souhaitez le remplir avec autre chose que 0, spécifiez la valeur N que vous souhaitez remplir, telle que constantes_valeurs = N.
Qu'en est-il d'un tableau à deux dimensions? Faisons le.
Z = np.array([[1,2,3],
[4,5,6]])
print(np.pad(Z, [1,1], mode="constant",constant_values=99))
Résultat d'exécution
[[99 99 99 99 99]
[99 1 2 3 99]
[99 4 5 6 99]
[99 99 99 99 99]]
«99» a été rempli autour du tableau d'origine.
- What is the result of the following expression? (★☆☆)
** "Et après? 』**
0 * np.nan
np.nan == np.nan
np.inf > np.nan
np.nan - np.nan
np.nan in set([np.nan])
0.3 == 3 * 0.1
Le résultat de l'exécution de chaque ligne est remis en question.
Tout d'abord, quel est le fréquent np.nan?" Nan (également écrit comme NaN) "signifie" Pas un nombre ", ou" non-nombre "en japonais.
Disons que c'est "un nombre, pas un nombre"
Symbole qui représente un non-nombre, même s'il est censé être un nombre suite à une opération en virgule flottante.
Ce NaN a deux caractéristiques principales.
** 1. Quelle que soit la valeur comparée (== ou grande ou petite), le résultat sera Faux **
#Comparez quelle valeur avec NaN(==Et grand et petit)Mais le résultat est faux
print(np.nan == 10)
print(np.nan > 10)
print(np.nan < 10)
print(np.nan == np.nan)
Résultat d'exécution
False
False
False
False
** 2. Quelle que soit la valeur ajoutée, soustraite, multipliée ou divisée, le résultat sera NaN **
#Quelle que soit la valeur ajoutée, soustraite, multipliée ou divisée par NaN, le résultat sera NaN.
print(np.nan + 10)
print(np.nan - 10)
print(np.nan * 10)
print(np.nan / 10)
Résultat d'exécution
nan
nan
nan
nan
Au fait, si vous tapez type (np.nan) et vérifiez le type de np.nan, ce sera float.
C'est juste un nombre, pas un nombre. C'est un peu étrange.
Maintenant, sur la base de ce qui précède, examinons le problème ligne par ligne.
0 * np.nan
Peu importe ce que vous multipliez par NaN, le résultat est NaN. Ce n'est pas une exception même s'il vaut 0.
print(0 * np.nan)
Résultat d'exécution
nan
np.nan == np.nan
Peu importe combien vous comparez avec NaN, c'est faux.
print(np.nan == np.nan)
Résultat d'exécution
False
np.inf > np.nan
«np.inf» signifie «infini». Peu importe combien vous comparez avec NaN, ce sera faux. C'est faux même par rapport à l'infini.
print(np.inf > np.nan)
Résultat d'exécution
False
np.nan - np.nan
NaN peut être obtenu en ajoutant, en soustrayant, en multipliant ou en divisant NaN.
print(np.nan - np.nan)
Résultat d'exécution
nan
np.nan in set([np.nan])
Y a-t-il un np.nan dans l'ensemble np.nan, qui est vrai.
print(np.nan in set([np.nan]))
Résultat d'exécution
True
0.3 == 3 * 0.1
Cela semble être vrai à première vue, mais le résultat est faux.
En décimal, 0,3 vaut 0,3, mais à l'intérieur de l'ordinateur, les nombres à virgule flottante sont représentés par ** binaire **. Par conséquent, il ne peut pas représenter exactement la même valeur que le nombre décimal 0,3.
Puisqu'il est plus facile à comprendre en le voyant réellement, utilisons format () pour afficher "0.3" et "3 * 0.1" avec 20 chiffres après la virgule décimale.
print(format(0.3, '.20f'))
print(format(3 * 0.1, '.20f'))
Résultat d'exécution
0.29999999999999998890
0.30000000000000004441
Vous pouvez voir que ni l'un ni l'autre n'est exactement 0,3.
Par conséquent, "0,3" et "3 * 0,1" ne sont pas équivalents, donc 0,3 == 3 * 0,1 est faux.
print(0.3 == 3 * 0.1)
Résultat d'exécution
False
- Create a 5x5 matrix with values 1,2,3,4 just below the diagonal (★☆☆) ** "Créez une séquence 5x5 où les composants immédiatement sous les composants diagonaux sont 1,2,3,4" **
C'est difficile à comprendre, mais je me demande si je devrais faire un tableau comme celui-ci.
Utilisez np.diag () pour travailler avec les composantes diagonales de la séquence.
Si vous spécifiez un vecteur ou une liste comme argument, une matrice carrée avec celui-ci comme composante diagonale est créée.
print(np.diag([1,2,3,4]))
Résultat d'exécution
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
Vous pouvez spécifier un autre paramètre appelé k dans np.diag ().
Par exemple, np.diag (v, k = n) générera un tableau dans lequel n éléments au-dessus de la composante diagonale sont v. (Si n est un nombre négatif, l'élément n sous la composante diagonale est v)
Le problème cette fois n'est pas la composante diagonale, mais l'élément immédiatement en dessous de la composante diagonale est 1,2,3,4, donc Spécifiez k = -1 dans l'argument de np.diag ().
100_Numpy_exercises.ipynb-(18)answer
Z = np.diag([1,2,3,4],k=-1)
print(Z)
Résultat d'exécution
100_Numpy_exercises.ipynb-(18)output
[[0 0 0 0 0]
[1 0 0 0 0]
[0 2 0 0 0]
[0 0 3 0 0]
[0 0 0 4 0]]
- Create a 8x8 matrix and fill it with a checkerboard pattern (★☆☆) ** "Créer un tableau de motifs en damier 8x8" **
Le motif en damier est un tel motif. C'est aussi appelé un motif à damier.
La couleur blanche de ce motif est "0" et la couleur noire est "1", et la disposition suivante peut être créée.
Commencez par créer un tableau 8x8 avec les 0 éléments, puis réécrivez tous les autres éléments en 1.
100_Numpy_exercises.ipynb-(19)answer
Z = np.zeros((8,8),dtype=int)
Z[::2,::2] = 1
Z[1::2,1::2] = 1
print(Z)
Résultat d'exécution
100_Numpy_exercises.ipynb-(19)output
[[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]]
- Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element? ** "Quel est l'indice (x, y, z) du 100e élément dans un tableau multidimensionnel 6x7x8? 』**
Par souci de simplicité, nous utiliserons une matrice 3x3.
Les réseaux multidimensionnels peuvent également être agencés dans une dimension et indexés à partir de la tête. À ce moment-là, par exemple, le cinquième élément (l'indice est ** 4 **) dans la figure ci-dessus est exprimé comme ** (1,1) ** lorsqu'il est exprimé par l'indice d'un tableau bidimensionnel 3 × 3. peut faire.
Vous pouvez considérer np.unravel_index () comme une fonction qui convertit un index exprimé dans une dimension en un index dans un tableau multidimensionnel.
np.unravel_index(indices,shape)
L'argument index est un index unidimensionnel. shape spécifie la taille du tableau multidimensionnel.
Cette fois, je veux exprimer l'index du 100e élément comme un index dans un tableau multidimensionnel 6x7x8, afin que je puisse l'écrire comme suit. (Parce qu'il est 100e, l'indice sera 99)
100_Numpy_exercises.ipynb-(20)answer
print(np.unravel_index(99, (6,7,8)))
Résultat d'exécution
100_Numpy_exercises.ipynb-(20)output
(1, 5, 3)
C'est tout pour cette fois. J'ai un problème croustillant. La prochaine fois, je répondrai aux 21e à 30e questions.
Recommended Posts