Les séquences sont indispensables dans les calculs scientifiques et techniques. Effectuez des opérations de base sur des tableaux à l'aide de numpy.
(1) Création d'un tableau à partir de la "liste" (2) Affichage / récupération des éléments du tableau (3) Séquences "Ajouter" et "Concaténer" (4) Tri des éléments du tableau (5) "Quatre règles" de tableau (6) Application de fonctions aux éléments du tableau [Addendum] Différences par rapport au standard Python "(multiple) list"
import numpy as np
"""
Créer un "tableau"
"""
a_list = [0,1,2,3,4,5] # a_Créer une liste nommée liste et élément 0, 1, 2, 3, 4,Magasin 5
a_array = np.array(a_list) # a_Faire de la liste un "tableau"
print(a_array)
[0 1 2 3 4 5]
(2)
a_list = [0,1,2,3,4,5] # a_Créer une liste nommée liste et élément 0, 1, 2, 3, 4,Magasin 5
a_array = np.array(a_list) # a_Faire de la liste un "tableau"
print(a_array[0]) #Afficher l'élément zéro du tableau(Compter à partir de zéro) # A
print(a_array[1]) # **N ° 1#B
print(a_array[-1]) #Comptez à l'arrière. De derrière-1, -2, ...C'est dans l'ordre.#C
print(a_array[1:3]) #Numéro d'élément 1(Le deuxième élément en partant de la gauche car il compte à partir de zéro)Ou créez un tableau jusqu'au troisième élément du tableau#D
print(a_array[2:]) #Numéro d'élément 2(Le troisième élément en partant de la gauche car il compte à partir de zéro)Créer un tableau contenant de à un avant le dernier élément#D
print(a_array[:4]) #Créer un tableau contenant les numéros d'élément 0 à 4e élément du tableau#F
0 #A 1 #B 5 #C [1 2] #D [2 3 4 5] #E [0 1 2 3] EF
(Remarque) Le dernier alphabet correspond à l'alphabet dans la ligne de sortie de la fonction d'impression dans le code ci-dessus.
Soit np.append (tableau, élément).
exemple(3-1)
import numpy as np
a_list = [0,1,2,3,4,5] # a_Créer une liste nommée liste et élément 0, 1, 2, 3, 4,Magasin 5
a_array = np.array(a_list) # a_Faire de la liste un "tableau"
a_array = np.append(a_array,10) #élément'10'Organiser un_Ajouter au tableau
print(a_array)
[ 0 1 2 3 4 5 10]
exemple(3-2)Concaténation de séquences
import numpy as np
a_list = [0,1,2,3,4,5] # a_Créer une liste nommée liste et élément 0, 1, 2, 3, 4,Magasin 5
a_array = np.array(a_list) # a_la liste est "tableau" a_en faire un tableau
b_list=[200, 300, 400] #b_Créer une liste nommée liste et élément 200, 300,Magasin 400
b_array = np.array(b_list) # b_la liste est "tableau" b_en faire un tableau
a_array = np.append(a_array, b_array) ##Array a_Tableau b dans le tableau_Concaténer le tableau
print(a_array)
[ 0 1 2 3 4 5 200 300 400]
Utilisez sort pour obtenir un tableau (croissant) dans lequel les éléments du tableau sont classés du plus petit nombre au plus grand nombre. Utilisez les options trié et ** inverse ** pour trier dans l'ordre inverse (ordre décroissant) du tri.
(4)Trier
import numpy as np
c_list = [14, 90, 4, 23, 61, 110, 75]
c_array = np.array(c_list)
sorted1=np.sort(c_array) #Séquence c_Construisez un tableau nommé sorted1 avec des tableaux organisés par ordre croissant
sorted2=np.array(sorted(c_array, reverse=True)) #Séquence c_Construisez un tableau nommé sorted2 avec des tableaux classés par ordre décroissant
print(sorted1)
print(sorted2)
[ 4 14 23 61 75 90 110] [110 90 75 61 23 14 4]
import numpy as np
"""
"Quatre règles" de tableau
"""
D1_array=np.array([1, 2, 3])
D2_array=np.array([4, 5, 6])
print(D1_array+D2_array) #Ajouter= numpy.add(D1_array, D2_array) #A
print(D1_array-D2_array) #Soustraire= numpy.subtract(D1_array, D2_array)#B
print(D1_array*D2_array) #Multiplier= numpy.multiply(D1_array, D2_array) #C
print(D1_array/D2_array) #division= numpy.divide(D1_array, D2_array) #D
print(D1_array%D2_array) #Surplus= numpy.add(D1_array, D2_array) #E
print(D1_array**D2_array) #Puissance numpy.power(D1_array, D2_array) #F
[5 7 9] #A [-3 -3 -3] #B [ 4 10 18] #C [ 0.25 0.4 0.5 ] #D [1 2 3] #E [ 1 32 729] #F
(Remarque) L'alphabet à la fin de la liste correspond à l'alphabet sur la ligne de sortie de la fonction d'impression dans le code ci-dessus.
Exemple(6)Cartographie des fonctions
import numpy as np
"""
Appliquer la même fonction aux éléments du tableau
"""
D_array=np.array([1, 2, 3]) #Élément 1, 2,Tableau D avec 3_Construire un tableau
print(np.cos(D_array)) # D_Évaluer la valeur de la fonction cos avec tous les éléments du tableau comme arguments
print(np.sqrt(D_array)) # D_Fonction Sqrt avec tous les éléments du tableau comme arguments(racine)Évaluer la valeur
[ 0.54030231 -0.41614684 -0.9899925 ] [ 1. 1.41421356 1.73205081]
Un [objet] appelé ndarray créé par numpy.array (list) (https://ja.wikipedia.org/wiki/%E3%82%AA%E3%83%96%E3%82%B8%E3%82% A7% E3% 82% AF% E3% 83% 88_ (% E3% 83% 97% E3% 83% AD% E3% 82% B0% E3% 83% A9% E3% 83% 9F% E3% 83% B3 En comparant% E3% 82% B0)) avec un objet liste par python, il présente les caractéristiques suivantes (Référence [1]). Le traitement des calculs peut être accéléré de 1 et 2. Cela est dû au fait que la surcharge pendant le calcul (temps requis pour l'accès mémoire / appel de fonction) est réduite. Voir la référence [1] pour plus de détails.
[1] Kenji Nakaku, "Introduction à Python pour les calculs scientifiques et technologiques", Revue technique, 2016.