Introduction à Python numpy pandas matplotlib (pour ~ B3 ~ part2)

Utilisons le module!

L'une des forces de Python est le grand nombre de modules et de bibliothèques. Même si vous ne définissez pas les fonctions et les classes à usage général une par une, vous pouvez grandement améliorer l'efficacité du travail en utilisant des modules open source qui ont été prototypés dans le passé ou créés par nos prédécesseurs.

Utilisons maintenant une bibliothèque typique!

Numpy Numpy est une bibliothèque rapide et efficace pour les calculs numériques en Python. Utilisez l'instruction ʻimport` lors de l'utilisation de la bibliothèque.

import numpy as np

En ajoutant ʻas 〇〇 à la fin de l'instruction ʻimport Vous pouvez changer le nom du module en XX dans votre code. Cette fois, «numpy» est changé en «np». numpy utilise son propre tableau (un tableau de la classe ndarray). Voici des exemples d'objets de la classe ndarray.

import numpy as np

#Déclaration du tableau numpy
a = np.arange(15).reshape(3, 5)
b = np.array([1.2,3.5,5.1])
c = ([(1.5,2,3),(4,5,6)])
print(a)
print(b)
#Forme de tableau
print(a.shape)
#Dimensions du tableau
print(a.ndim)
#Types d'éléments de tableau
print(a.dtype.name)
#Nombre d'éléments dans le tableau
print(a.size)

#Affichage du tableau
#Array a
[[ 0  1  2  3  4 ]
 [ 5  6  7  8  9 ] 
 [10 11 12 13 14 ]]
#Tableau b
[1.2 3.5 5.1 ]
#Séquence c
[(1.5, 2, 3), (4, 5, 6)]
#Forme de tableau
(3, 5)
#Nombre de dimensions du tableau
2
#Types d'éléments de tableau
int64
#Nombre d'éléments dans le tableau
15

Vous pouvez générer un tableau Numpy à l'aide de l'attribut ** array **. Les tableaux multidimensionnels peuvent également être facilement créés. Utilisez la ** propriété shape ** pour vérifier le nombre d'éléments tels que les lignes et les colonnes. Vous pouvez vérifier le nombre total d'éléments avec la propriété ** size **. Aussi, si vous voulez vérifier de quel type sont les éléments de la matrice (int, float, etc.) Vous pouvez le faire en utilisant la ** propriété type **.

Matrice zéro Matrice vide

Matrice zéro, matrice avec tous les éléments mis à 1, matrice vide Vous pouvez également le générer.

import numpy as np

print(np.zeros((3,4)))
print(np.ones((2,3,4),dtype = np.int16))
print(np.empty((2,3)))

#Matrice zéro
[[0. 0. 0. 0. ]
 [0. 0. 0. 0. ]
 [0. 0. 0. 0. ] ]

#Une matrice avec tous les éléments 1
[[[1 1 1 1 ]
  [1 1 1 1 ]
  [1 1 1 1] ]

 [[1 1 1 1 ]
  [1 1 1 1 ]
  [1 1 1 1 ] ] ]

#Matrice Numpy vide
[[1.39069238e-309 1.39069238e-309 1.39069238e-309 ]
 [1.39069238e-309 1.39069238e-309 1.39069238e-309 ] ]

Défis

Faisons une matrice unitaire 5 * 5 à partir d'une matrice nulle. Je vous laisse comment mettre les composantes diagonales.

Disposition des éléments avec numéros de série et sauts 〇

Comme mentionné ci-dessus, vous pouvez également utiliser l'attribut ** arrange ** pour générer un tableau Numpy dans lequel les éléments sont entrés dans l'ordre spécifié. Dans np.arange. (Stop), n jusqu'à 0 <= n <stop est entré dans l'ordre. Dans np.arange. (Start, stop), n jusqu'à start <= n <stop est entré dans l'ordre. Avec np.arange. (Start, stop, step), n jusqu'à start <= n <stop est entré en sautant step. Le nombre à sauter correspond à un petit nombre.

print(np.arange(10))
print(np.arange(0,10))
print(np.arange(10,30,5))
print(np.arange(0,2,0.3))

[0 1 2 3 4 5 6 7 8 9 ]
[0 1 2 3 4 5 6 7 8 9 ]
[10 15 20 25 ]
[0.  0.3 0.6 0.9 1.2 1.5 1.8 ]

Il existe également un ** attribut linspace ** qui divise la plage «[start: stop)» en le nombre spécifié d'éléments à intervalles réguliers.

print(np.linspace(0,2,9))

[0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]

Quatre règles du tableau Numpy

Dans les quatre règles du tableau Numpy, le calcul est essentiellement effectué entre les mêmes éléments de ligne et de colonne.

A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
print(A+B)
print(A-B)
print(A*B)

#A+B
[[3 1 ]
 [3 5 ] ]
#A-B
[[ - 1  1 ]
 [ - 3 - 3 ] ]
#A*B
[[2 0 ]
 [0 4 ] ]

Si vous voulez trouver le produit intérieur au lieu de multiplier les éléments carrés, utilisez «@» ou «dot function».

print(A@B)
print(A.dot(B))

#A@B
[[5 4 ]
 [3 4 ]]
#A.dot(B)
[[5 4 ]
 [3 4 ]]

Racine carrée quaternaire

La puissance de la baie Numpy est calculée entre les baies (A ** B) La puissance B [i] de A [i] est émise. La racine carrée est également traitée pour chaque élément.

a = np.arange(1, 11, 1)
b = np.array([1,2,1,2,1,2,1,2,1,2])
print(np.power(a, b))
print(np.sqrt(a))

[  1   4   3  16   5  36   7  64   9 100 ]
[1.   1.41421356 1.73205081 
 2.   2.23606798 2.44948974 2.64575131 2.82842712 
 3.   3.16227766 ]

Fonction trigonométrique

Numpy prend également en charge les fonctions triangulaires et bicourbes. Attention car l'argument est ** radian **.

print(np.sin(0))
print(np.cos(0))
print(np.tan(np.pi/4))
print(np.tanh(2))

0.0
1.0
0.9999999999999999
0.9640275800758169

Il existe également une fonction de triangle inverse. La sortie est également ** radian **.

print(np.arcsin(1.0))
print(np.arcsin(1.0)*2/np.pi)
print(np.arccos(-1.0))
print(np.arctan(-0.5))

#arcsin(1.0)
1.5707963267948966
#arcsin(1.0)*2/np.pi
1.0
#arccos(-1.0)
3.141592653589793
#arctan(-0.5)
- 0.4636476090008061

Comptage des éléments

Il existe plusieurs fonctions qui comptent tous les éléments d'un tableau Numpy.

onehot = np.array([0, 1, 1, 0, 1, 0, 1, 1])

#Exemple de comptage du nombre de 1
print(np.count_nonzero(onehot))                    
print(len(np.where(onehot != 0)[0])) 

#Exemple de comptage du nombre de 0
print(np.count_nonzero(1 - onehot)) 
 
#Exemple de comptage de 0 et 1 en même temps
#Utilisation d'une fonction unique
print(np.unique(onehot, return_counts=True))

#Afficher dans le type de dictionnaire
unique, count = np.unique(onehot, return_counts=True)
print(dict(zip(unique, count)))

#Utilisation de la fonction bincount
c = np.bincount(onehot)
print(c)   

#Nombre de 1
5    #count_nonzero
5    #len(np.where(onehot != 0)[0])
#Nombre de 0
3    #count_nonzero(1 - onehot)
#Comptez en même temps
(array([0, 1]), array([3, 5]))    #unique
{0: 3, 1: 5}                      #Sorte de dictionnaire
[3 5 ]                            #

En particulier, la «fonction unique» et la «fonction bincount» comptent tous les types d'éléments. La différence entre les deux est que la «fonction unique» n'affiche pas le nombre de valeurs qui n'existent pas dans le tableau Numpy.

A = np.array([2,3,4,3,4,4,4,6,7,1])
#Utilisation d'une fonction unique
u,c = np.unique(A,return_counts=True)
print(dict(zip(u,c)))
#Utilisation de la fonction bincount
print(np.bincount(A))

#Utilisation d'une fonction unique
{1: 1, 2: 1, 3: 2, 4: 4, 6: 1, 7: 1}
#Utilisation de la fonction bincount
[0 1 1 2 4 0 1 1 ]

Défis

Créer un tableau de valeurs entrées dans chaque fonction sin par π / 4 (de 0 à 4π) Comptez chaque élément.

Extraire le plus grand élément et le plus petit élément

Pour récupérer les indices (index) des éléments les plus grands et les plus petits d'un tableau, utilisez la «fonction argmax» et la «fonction argmin». L'indice (index) est la position de l'élément.

A = np.array([2,4,3,6,7,8,8,5,4,7,8])
#Valeur maximale de l'élément
print(np.max(A))
#Indice maximum
print(np.argmax(A))
print(A.argmax())
#Valeur minimale de l'élément
print(np.min(A))
#Indice minimum
print(np.argmin(A))
print(A.argmin())

#Valeur maximale de l'élément
8
#Index de la valeur maximale de l'élément
5
5
#Valeur minimale de l'élément
2
#Index de la valeur minimale de l'élément
0
0

ʻArgmax, fonction argminest Il existe deux types,np.argmax (argmin)etnp.ndarray.argmax (argmin). La fonction np.argmaxspécifie un tableau comme premier argument de la fonction et Lafonction np.ndarray.argmax` est utilisée en l'appelant comme une méthode. L'index «5» du plus grand élément du tableau A à partir de l'index «0» est affiché. Chaque argument a un paramètre «axe», qui recherche les valeurs maximum et minimum sur l'axe spécifié même dans un tableau multidimensionnel.

B = np.array([[2,4,5],[9,2,8]])
#axe(axis=0)Valeur maximale de chaque élément basée sur
print(B.max(axis=0))
#axe(axis=0)Index de la valeur maximale de chaque élément basé sur
print(B.argmax(axis=0))
#Axe(axis=1)Valeur maximale de chaque élément comme référence
print(B.max(axis=1))
#axe(axis=1)Index de la valeur maximale de chaque élément basé sur
print(B.argmax(axis=1))

#axe(axis=0)Valeur maximale de chaque élément basée sur
[9 4 8 ]
#axe(axis=0)Index de la valeur maximale de chaque élément basé sur
[1 0 1 ]
#Axe(axis=1)Valeur maximale de chaque élément comme référence
[5 9 ]
#axe(axis=1)Index de la valeur maximale de chaque élément basé sur
[2 0 ]

Lorsque ʻaxis = 0, l'index de la valeur maximale de chaque colonne du tableau est affiché. Lorsque ʻaxis = 1, l'indice de la valeur maximale de chaque ligne du tableau est affiché.

Défis

Tableau des tâches précédentes Valeurs maximales et minimales Trouvez le premier index.

Pandas Pandas est un outil d'analyse et de manipulation de données open source rapide, puissant, flexible et facile à utiliser. Tout d'abord, importons la bibliothèque.

import pandas as pd

Ensuite, chargeons l'ensemble de données Iris à partir du référentiel UCI Machine Learning. Chez les pandas, la table de données s'appelle ** DataFrame **. df est une abréviation, donc le nom n'a pas de signification particulière, Souvent déclaré comme «df».

import pandas as pd
#Affichage des trames de données
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',header=None)
print(df)

#Affichage des trames de données
       0    1    2    3               4
0    5.1  3.5  1.4  0.2     Iris-setosa
1    4.9  3.0  1.4  0.2     Iris-setosa
2    4.7  3.2  1.3  0.2     Iris-setosa
3    4.6  3.1  1.5  0.2     Iris-setosa
4    5.0  3.6  1.4  0.2     Iris-setosa
..   ...  ...  ...  ...             ...
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica

[150 rows x 5 columns]

Je pense que je pourrais le lire comme ça. Si vous voulez vérifier uniquement le début et la fin, utilisez head, tail function.

#Affichage des 10 premières lignes
print(df.head(n=10))
#Affichage des 5 dernières lignes
print(df.tail(n=5))

#Affichage des 10 premières lignes
     0    1    2    3            4
0  5.1  3.5  1.4  0.2  Iris-setosa
1  4.9  3.0  1.4  0.2  Iris-setosa
2  4.7  3.2  1.3  0.2  Iris-setosa
3  4.6  3.1  1.5  0.2  Iris-setosa
4  5.0  3.6  1.4  0.2  Iris-setosa
5  5.4  3.9  1.7  0.4  Iris-setosa
6  4.6  3.4  1.4  0.3  Iris-setosa
7  5.0  3.4  1.5  0.2  Iris-setosa
8  4.4  2.9  1.4  0.2  Iris-setosa
9  4.9  3.1  1.5  0.1  Iris-setosa
#Affichage des 5 dernières lignes
       0    1    2    3               4
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica

Vérifions la forme de l'ensemble de données.

#Vérifiez le nombre de lignes et de colonnes
print(df.shape)
#Vérifier l'index
print(df.index)
#Vérifiez la colonne
print(df.columns)
#Vérifiez le type de données de chaque colonne de dataframe
print(df.dtypes)

#Vérifiez le nombre de lignes et de colonnes
(150, 5)
#Vérifier l'index
RangeIndex(start=0, stop=150, step=1)
#Vérifiez la colonne
Int64Index([0, 1, 2, 3, 4], dtype='int64')
#Vérifiez le type de données de chaque colonne de dataframe
0    float64
1    float64
2    float64
3    float64
4     object
dtype: object

Les statistiques des blocs de données peuvent être trouvées avec la fonction «describe ()».

print(df.describe())

                0           1           2           3
count  150.000000  150.000000  150.000000  150.000000
mean     5.843333    3.054000    3.758667    1.198667
std      0.828066    0.433594    1.764420    0.763161
min      4.300000    2.000000    1.000000    0.100000
25%      5.100000    2.800000    1.600000    0.300000
50%      5.800000    3.000000    4.350000    1.300000
75%      6.400000    3.300000    5.100000    1.800000
max      7.900000    4.400000    6.900000    2.500000

Vous pouvez également récupérer uniquement une partie du bloc de données.

#100~Obtenez les 109 données
print(df[100:110],"\n\n")
#Obtenez uniquement les 100 données
print(df.loc[100],"\n\n")
#0~Obtenez uniquement la 4e colonne de 100 lignes
print(df.iloc[0:100,4])

       0    1    2    3               4
100  6.3  3.3  6.0  2.5  Iris-virginica
101  5.8  2.7  5.1  1.9  Iris-virginica
102  7.1  3.0  5.9  2.1  Iris-virginica
103  6.3  2.9  5.6  1.8  Iris-virginica
104  6.5  3.0  5.8  2.2  Iris-virginica
105  7.6  3.0  6.6  2.1  Iris-virginica
106  4.9  2.5  4.5  1.7  Iris-virginica
107  7.3  2.9  6.3  1.8  Iris-virginica
108  6.7  2.5  5.8  1.8  Iris-virginica
109  7.2  3.6  6.1  2.5  Iris-virginica 


0               6.3
1               3.3
2                 6
3               2.5
4    Iris-virginica
Name: 100, dtype: object 


0         Iris-setosa
1         Iris-setosa
2         Iris-setosa
3         Iris-setosa
4         Iris-setosa
           ...       
95    Iris-versicolor
96    Iris-versicolor
97    Iris-versicolor
98    Iris-versicolor
99    Iris-versicolor
Name: 4, Length: 100, dtype: object

Mappage des fonctionnalités de commande

Par exemple, lorsque la quantité de caractéristiques est ordonnée telle que la taille des vêtements, en mappant la quantité de caractéristiques à un entier, etc. Les algorithmes d'apprentissage seront capables d'interpréter correctement les caractéristiques ordinales. Il permet également la conversion inverse.

df = pd.DataFrame([
                   ['green','M',10.1,'class1'],
                   ['red','L',13.5,'class2'],
                   ['blue','XL',15.3,'class1']
])
#Définir le nom de la colonne
df.columns = ['color','size','price','classlabel']
print(df,"\n")
size_mapping = {'XL':3,'L':2,'M':1}
df['size']= df['size'].map(size_mapping)
print(df,"\n")
#Définir une fonction pour la conversion inverse
inv_size_mapping = {v:k for k,v in size_mapping.items()}
df['size']=df['size'].map(inv_size_mapping)
print(df)

   color size  price classlabel
0  green    M   10.1     class1
1    red    L   13.5     class2
2   blue   XL   15.3     class1 
#Après la conversion
   color  size  price classlabel
0  green     1   10.1     class1
1    red     2   13.5     class2
2   blue     3   15.3     class1 
#Après conversion inverse
   color size  price classlabel
0  green    M   10.1     class1
1    red    L   13.5     class2
2   blue   XL   15.3     class1

Codage des étiquettes de classe

Les bibliothèques de machine learning nécessitent souvent des étiquettes de classe sous forme de valeurs entières, donc encodez-les. Préparez la conversion inverse ainsi que la quantité de fonction commandée.

class_mapping = {label:idx for idx, label in enumerate(np.unique(df['classlabel']))}
df['classlabel']=df['classlabel'].map(class_mapping)
print(df,"\n")
inv_class_mapping = {v : k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)
print(df)

   color size  price  classlabel
0  green    M   10.1           0
1    red    L   13.5           1
2   blue   XL   15.3           0 

   color size  price  classlabel
0  green    M   10.1           0
1    red    L   13.5           1
2   blue   XL   15.3           0

Encodage à chaud

Convertir des variables catégorielles en variables factices

Il est rare que les éléments de classification de la classification de classification d'apprentissage automatique soient des valeurs numériques telles que la classe 1, la classe 2 ... depuis le début. Par exemple, lors de la classification des hommes et des femmes, il peut être plus facile de les convertir en variables fictives telles que 0 et 1. Vous pouvez également convertir des entités multi-classes en une représentation unique. Dans un tel cas, la fonction `get_dummies () 'est pratique. Cette fois, nous effectuerons un ** encodage à chaud ** pour les couleurs qui sont un type de quantité de caractéristiques appelée quantité nominale de caractéristiques sans ordre.

pd.get_dummies(df[['price','color','size']])

    price size	color_blue	color_green	color_red
0	10.1	1      0	        1           0
1	13.5	2      0	        0           1
2	15.3	3      1	        0           0

Reconstituer les valeurs manquantes

Toutes les données ne sont pas complètement remplies. Dans un tel cas, il est nécessaire de renseigner la valeur manquante (NaN).

from io import StringIO
#Créer des exemples de données
csv_data = '''A,B,C,D 
              1.0,2.0,3.0,4.0
              5.0,6.0,,8.0
              10.0,11.0,12.0,'''
df = pd.read_csv(StringIO(csv_data))
print(df)
print(df.describe())

Où StringIO est la chaîne affectée à la variable csv_data Il est utilisé pour pouvoir être lu dans un objet DataFrame.

    A     B     C   D 
0   1.0   2.0   3.0  4.0
1   5.0   6.0   NaN  8.0
2  10.0  11.0  12.0  NaN
               A          B          C        D 
count   3.000000   3.000000   2.000000  2.000000
mean    5.333333   6.333333   7.500000  6.000000
std     4.509250   4.509250   6.363961  2.828427
min     1.000000   2.000000   3.000000  4.000000
25%     3.000000   4.000000   5.250000  5.000000
50%     5.000000   6.000000   7.500000  6.000000
75%     7.500000   8.500000   9.750000  7.000000
max    10.000000  11.000000  12.000000  8.000000

Deux valeurs manquantes ont été trouvées dans ce DataFrame. Lorsque le DataFrame est énorme, il y a une limite à ce qui peut être confirmé visuellement, alors essayez de rechercher les données manquantes avec la fonction ʻisnull () `.

print(df.isnull(),"\n")
print(df.isnull().sum())

       A      B      C     D 
0  False  False  False  False
1  False  False   True  False
2  False  False  False   True 

A     0
B     0
C     1
D     1
dtype: int64

Nous savons maintenant qu'il manque des valeurs dans les colonnes C et D. Cette fois, nous les compléterons par la médiane des autres valeurs de la même colonne. Utilisez la fonction fillna () pour terminer.

df["C"]=df["C"].fillna(df["C"].median())
df["D"]=df["D"].fillna(df["D"].median())
print(df.isnull().sum())

A    0
B    0
C    0
D    0
dtype: int64

Cela remplit les valeurs manquantes.

D'autre part, il est également possible de supprimer des lignes et des colonnes avec des valeurs manquantes avec la méthode dropna ().

csv_data = '''A,B,C,D
              1.0,2.0,3.0,4.0
              5.0,6.0,,8.0
              10.0,11.0,12.0,'''
df = pd.read_csv(StringIO(csv_data))
print(df.dropna(),"\n")
print(df.dropna(axis=1))

     A    B    C    D
0  1.0  2.0  3.0  4.0 

      A     B
0   1.0   2.0
1   5.0   6.0
2  10.0  11.0

Dans la méthode `dropna () ', si rien n'est mis dans l'argument, la ligne (axis = 0) et l'axe sont mis dans l'argument pour supprimer la colonne contenant la valeur manquante dans le sens axial.

Les défis d'ici

https://www.kaggle.com/ Obtenez l'ensemble de données de kaggle.

Entrez mon compte.

Cliquez sur

Je pense que le fichier Kaggle.json est enregistré. Passez à Google Colab.

Entrez ce qui suit:

from google.colab import files
files.upload()
!mkdir -p ~/.kaggle
!mv kaggle.json ~/.kaggle/
!chmod 600 /root/.kaggle/kaggle.json
!pip install kaggle
!kaggle competitions download -c titanic

Puis files.upload () démarrera Un champ de sélection de fichier comme celui-ci apparaîtra, alors sélectionnez le fichier Kaggle.json que vous avez enregistré précédemment. Ensuite, la commande ci-dessous enregistre les données titanesques dans le dossier kaggle, utilisez donc ces données de train.

df = pd.read_csv('/content/train.csv',header=None)
print(df.tail(n=10))

     0  1  2   ...       9     10 11
882  882  0  3  ...   7.8958   NaN  S
883  883  0  3  ...  10.5167   NaN  S
884  884  0  2  ...     10.5   NaN  S
885  885  0  3  ...     7.05   NaN  S
886  886  0  3  ...   29.125   NaN  Q
887  887  0  2  ...       13   NaN  S
888  888  1  1  ...       30   B42  S
889  889  0  3  ...    23.45   NaN  S
890  890  1  1  ...       30  C148  C
891  891  0  3  ...     7.75   NaN  Q

[10 rows x 12 columns ]

1. Recherchez la colonne contenant la valeur manquante.
2. Remplissez les colonnes avec des valeurs manquantes qui indiquent des nombres avec des valeurs médianes.
3. Mettez un S dans la valeur manquante de la colonne dont la colonne est Embarquée (la valeur la plus fréquente était "S").
4. Effacez les colonnes restantes avec les éléments les plus manquants.
5. Si l'élément est une chaîne, convertissons factices les éléments de la colonne Sex et de la colonne Embarked en valeurs numériques. Cependant, le sexe est composé de deux chaînes de catégorie «homme» et «femme», et Embarqué est composé de trois chaînes de «S», «C» et «Q».

Matplotlib ** Matplotlib ** est une bibliothèque complète pour créer des visualisations statiques, animées et interactives. La visualisation est une tâche relativement importante. Dans de nombreux cas, la corrélation peut être vue en visualisant des données difficiles à voir avec juste une chaîne de caractères. Importons-le maintenant.

import matplotlib.pyplot as plt

Trouvons une simple ligne droite numérique.

plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Tracez les données avec la fonction de tracé. Cette fois, celui correspondant à l'axe des x n'est pas explicitement décrit, mais lorsqu'un seul tableau est spécifié, il est automatiquement considéré comme une séquence de valeurs y et une valeur x est générée. Vous pouvez spécifier le nom de l'étiquette de l'axe y avec la fonction ylabel. C'est ainsi que fonctionne le tracé x à y.

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('x-axis')
plt.ylabel('y-axis')

Bien sûr, vous pouvez également vous disperser.

import numpy as np
t = np.arange(0., 5., 0.2)
# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)
# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bX', t, t**3, 'g^',t,t**4,'y*')
plt.show()

Ici, r -, bs,g ^, y-, etc. sont des paramètres de tracé, et le premier caractère alphabétique est l'abréviation de couleur. Il existe huit types d'abréviations: {b (lue), g (ray), r (ed), c (ian), m (asenta), y (ellow), k (ey-plate black), w (hite)} il y a. Si vous voulez essayer d'autres couleurs https://qiita.com/KntKnk0328/items/5ef40d9e77308dd0d0a4 Vois ici. De plus, les types de ligne du tracé sont les suivants.

Il existe différents marqueurs.

Dessin 3D, dessin de ligne de contour

Il est également possible d'afficher un tracé dans l'espace 3D sous forme de ligne de contour ou de graphique 3D.

from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#Création de points de grille
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
#Calcul de la valeur de la fonction à chaque point
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

fig_1 = plt.figure()
ax = Axes3D(fig_1)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.viridis)
fig_2, ax_2 = plt.subplots(figsize=(8, 6))
#Affichage des courbes de niveau
contour = ax_2.contourf(X, Y, Z)
#Affichage de la barre de couleur
fig_2.colorbar(contour)
plt.show()

Tout d'abord, créez un point de grille avec la fonction numpy.meshgrid. Calculez ensuite la valeur de la fonction sur les points de la grille. Cette fois, je dessine Z. Dessiner un graphe 3D se fait en passant plot_surface (X, Y, Z) comme argument. La signification des autres arguments est

Les lignes de contour sont dessinées à l'aide de la fonction countourf. De plus, la table de correspondance (barre de couleur) des valeurs des lignes de contour est affichée en passant les lignes de contour à la «fonction barre de couleur».

Défis

Dessinons vos données 3D préférées!

Colorez la zone fermée

La fonction fill_between prend en charge le remplissage de la zone qui peut être créée lorsqu'il y a deux fonctions ou plus.

x = np.arange(0,5,0.01)
y1 = np.sin(x) 
y2 = np.cos(x)
plt.plot(x,y1,color='k',label="sin")
plt.plot(x,y2,color='r',label="cos")
plt.legend()
plt.fill_between(x,y1,y2,color='b',alpha = 0.1)

Afficher une image ou un tableau à deux dimensions

Utilisez la «fonction imshow» pour afficher une image existante ou un tableau bidimensionnel contenant les valeurs de chaque pixel. L'image est affichée en passant un objet tableau ou une image PIL comme premier argument.

Enregistrez votre image préférée au format jpeg et commencez à partir du fichier de gauche

Je vais le télécharger.

import matplotlib.image as mpimg
img = mpimg.imread("〇〇.jpg ")
plt.imshow(img)

Si vous entrez le nom du fichier à la place de «〇〇.jpg», l'image doit être affichée.

Pour afficher le tableau, procédez comme suit. Tracons un tableau aléatoire à deux dimensions.

x = np.random.random((100, 100))
plt.imshow(x, cmap="plasma")
plt.colorbar()