Python pour l'analyse des données Chapitre 4

NumPy Basics: Arrays and Vectorized Computation

ndarray Objet de tableau à n dimensions fourni par NumPy Creating dnarrays

#Créé à partir d'un tableau
data1 = [6, 7.5, 8, 9]
arr1 = np.array(data1)

#Peut également être créé dans des tableaux multidimensionnels
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)

#fonction de plage python
np.arange(10)

#Zéro vecteur
np.zeros(10)

#Matrice zéro
np.zeros((3, 6))

#Générer sans initialisation
np.empty((2, 3, 2))

#Confirmation des dimensions
arr2.ndim

#Forme de tableau
arr2.shap

#Confirmation du type de données
arr1.dtype

#Générer en spécifiant le type de données
arr1 = np.array([1, 2, 3], dtype=np.float64)

#Généré à partir d'une chaîne
data3 = ["1.1", "2.2", "3.3"]
arr3 = np.array(data3, dtype=float64)

Operations between Arrays and Scalars

#Le calcul entre les tableaux est un calcul entre le même endroit
arr = np.array([[1, 2, 3], [4, 5, 6]])
"""
In [32]: arr
Out[32]: 
array([[1, 2, 3],
       [4, 5, 6]])
"""
arr * arr
"""
In [33]: arr * arr
Out[33]: 
array([[ 1,  4,  9],
       [16, 25, 36]])
"""

#Le calcul avec scalaire est calculé pour tous les éléments
arr - 1
"""
In [34]: arr - 1
Out[34]: 
array([[0, 1, 2],
       [3, 4, 5]])
"""
1 / arr
"""
In [35]: 1 / arr
Out[35]: 
array([[1, 0, 0],
       [0, 0, 0]])
"""

Basic Indexing and Slicing / Fancy Indexing

La spécification de l'élément est la même que la matrice mathématique (ligne, colonne)

__Si vous voulez une copie d'une tranche de tableau, si vous ne la copiez pas, la tranche changera lorsque le tableau d'origine change __ arr[5:8].copy()

Boolean Indexing Vous pouvez masquer le tableau en utilisant le tableau booléen

name = np.array(["bob", "martin" ,"feed","max","rosetta","john"])
"""
In [63]: name == "bob"
Out[63]: array([ True, False, False, False, False, False], dtype=bool)
"""
arr = np.arange(6)
"""
In [68]: arr[name=="rosetta"]
Out[68]: array([4])
"""

Opérateur booléen & (and) | (or)

python

mask = (name=="rosetta") | (name=="martin")
"""
In [72]: mask
Out[72]: array([False,  True, False, False,  True, False], dtype=bool)
"""

Sélection par opérateur de comparaison

data = randn(10)
"""
In [78]: data
Out[78]: 
array([-0.43930899, -0.18084457,  0.50384496,  0.34177923,  0.4786331 ,
        0.0930973 ,  0.95264648,  1.29876589,  0.96616151,  0.69204729])
"""
data[data < 0] = 0
"""
In [80]: data
Out[80]: 
array([ 0.        ,  0.        ,  0.50384496,  0.34177923,  0.4786331 ,
        0.0930973 ,  0.95264648,  1.29876589,  0.96616151,  0.69204729])
"""

Transposing Arrays and Swapping Axes !! !! !! !! !! difficile! !! !! !! !! Je pense qu'il est plus facile de ne prendre que ce que vous voulez avec une part de fantaisie ...

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

#Translocation
arr.T

#produit intérieur
np.dot(arr.T, arr)

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

#Transformer en spécifiant l'axe
arr.transpose((1, 0, 2))

#Remplacement de l'arbre
arr.swapaxes(1, 2)

Universal Functions: Fast Element-wise Array Functions

1 fonction d'argument

Une fonction qui fonctionne sur une base élémentaire. Appliquez une fonction à chaque élément de x avec np.func (x).

Fonction à 2 arguments

Utilisé dans np.func (x1, x2).

Data Processing Using Arrays Visualisez des données bidimensionnelles. À titre d'exemple, affichez la grille qui a calculé sqrt (x ^ 2, y ^ 2).

#Créer 1000 points
points = np.arange(-5, 5, 0.01)
#Créer un maillage 2D
#x est un tableau à deux dimensions avec un tableau de x en lignes et y est un tableau de y en colonnes
xs, ys = np.meshgrid(points, points)
#Calcul
z = np.sqrt(xs ** 2 + ys ** 2)
#afficher
plt.imshow(z, cmap=plt.cm.gray); plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")

Expressing Conditional Logic as Array Operations np.where est une fonction qui renvoie le deuxième ou le troisième argument selon la valeur du premier argument. Autrement dit, np.where (cond, xarr, yarr) = [(x if c else y) for x, y, c in zip (xarr, yarr, cond)]

arr = randn(5, 5)
"""
In [5]: arr
Out[5]: 
array([[-0.63774199, -0.76558645, -0.46003378,  0.61095653,  0.78277454],
       [ 0.25332127,  0.50226145, -1.45706102,  1.14315867,  0.28015   ],
       [-0.76326506,  0.33218657, -0.18509161, -0.3410194 , -0.29194451],
       [-0.32247669, -0.64285987, -0.61059921, -0.38261289,  0.41530912],
       [-1.7341384 ,  1.39960857,  0.78411537,  0.25922757, -0.22972615]])
"""
arrtf = np.where(arr > 0, True, False)
"""
In [6]: arrtf
Out[6]: 
array([[False, False, False,  True,  True],
       [ True,  True, False,  True,  True],
       [False,  True, False, False, False],
       [False, False, False, False,  True],
       [False,  True,  True,  True, False]], dtype=bool)
"""

En les combinant, il est possible de classer par plusieurs conditions.

cond1 = np.where(randn(10) > 0, True, False)
cond2 = np.where(randn(10) > 0, True, False)
"""
In [16]: cond1
Out[16]: array([False,  True, False, False,  True,  True,  True,  True,  True,  True], dtype=bool)

In [17]: cond2
Out[17]: array([False, False, False, False, False,  True, False,  True,  True,  True], dtype=bool)
"""
result = np.where(cond1 & cond2, 0, np.where(cond1, 1, np.where(cond2, 2, 3)))
"""
In [19]: result
Out[19]: array([3, 1, 3, 3, 1, 0, 1, 0, 0, 0])
"""

If et else peuvent être réécrits.

result = []
for i in range(n):
    if cond1[i] and cond2[i]:
        result.append(0)
    elif cond1[i]:
        result.append(1)
    elif cond2[i]:
        result.append(2)
    else:
        result.append(3)

C'est également possible avec des formules. (Notez que 0 et 3 sont interchangés avec les autres) result = 1*cond1 + 2*cond2

Mathematical and Statistical Methods Des fonctions statistiques sont également disponibles.

arr = randn(5, 4)
arr.mean()
#L'axe peut également être spécifié
arr.mean(0)
arr.mean(1)
"""
In [60]: arr.mean()
Out[60]: 0.51585861805229682

In [62]: arr.mean(0)
Out[62]: array([ 0.65067115, -0.03856606,  1.06405353,  0.38727585])

In [63]: arr.mean(1)
Out[63]: array([ 1.18400902,  0.84203136,  0.50352006,  0.07445734, -0.0247247 ])
"""

• sum
• mean
• std, var
• min, max
• argmin, argmax (renvoie l'index maximum / minimum)
• cum (total progressif)
• cumprod (total cumulé)

Methods for Boolean Arrays Étant donné que le type booléen True est compté pour 1 et False est compté pour 0, le comptage par la fonction de somme est souvent utilisé.

arr = randn(100)
sumnum = (arr > 0).sum()
"""
In [75]: sumnum
Out[75]: 43
"""

Autres fonctions booléennes

• any (Vrai s'il y en a même un Vrai)
• all (Vrai si tout est Vrai)

Sorting Vous pouvez également trier. arr.sort()

Unique and Other Set Logic Vous pouvez également utiliser quelque chose comme la véritable fonction set Python.

• unique(x)
• intersect1d(x, y)（unique(x) & unique(y)）
• union1d(x, y)（unique(x) | unique(y)）
• in1d (x, y) (retourne un tableau de valeurs booléennes si l'élément de y est contenu dans x)
• setdiff1d (x, y) (valeur de x pas en y)
• setxor1d (x, y) (valeur de x pas en y & valeur de y pas en x)

File Input and Output with Arrays Vous pouvez enregistrer l'objet de tableau NumPy dans un fichier externe. Bien sûr, vous pouvez également charger et restaurer le fichier enregistré.

arr = np.arange(10)

#Enregistrer au format binaire
np.save("array_name", arr)
#Charger un fichier au format binaire
arr = np.load("array_name.npy")
#Enregistrer plusieurs tableaux dans zip
np.savez("array_archive.npz", a=arr, b=arr)
#Charger plusieurs fichiers zip
arr_a = np.load("array_archive.npz")["a"]
arr_b = np.load("array_archive.npz")["b"]

#Enregistrer au format csv
np.savetxt("array_ex.txt", arr, delimiter=",")
#Lire le fichier au format csv
arr = np.loadtxt("array_ex.txt", delimiter=",")

Linear Algebra Vous pouvez également calculer l'algèbre linéaire.

Random Number Generation Des valeurs aléatoires de diverses distributions peuvent être obtenues à grande vitesse.

Example: Random Walks Exécutez ce qui suit dans ipython

nsteps = 1000
draws = np.random.randint(0, 2, size=nsteps)
steps = np.where(draws > 0, 1, -1)
walk = steps.cumsum()
plt.plot(walk)

Simulating Many Random Walks at Once

nwalks = 100
nsteps = 1000
draws = np.random.randint(0, 2, size=(nwalks, nsteps))
steps = np.where(draws > 0, 1, -1)
walks = steps.cumsum(1)
plt.plot(walks)

Expansion Cela ne semble pas être une valeur aléatoire de très haute qualité, mais elle devrait être de très haute qualité car elle utilise en fait Mercennu Twister.