<jupyter_start><jupyter_text>NumpySi vous ne connaissez pas cette librairie, quelques fonctions qui peuvent être utiles pour gérer des opérations sur des tableaux.Un tutoriel est disponible sur https://docs.scipy.org/doc/numpy/user/quickstart.html si vous souhaitez compléter ce notebook.-- Import de la librairie<jupyter_code>import numpy as np<jupyter_output><empty_output><jupyter_text>Définition de tableau<jupyter_code>np.array((1,2,3))<jupyter_output><empty_output><jupyter_text>Mais on peut aussi spécifier un type dans la définition de tableaux<jupyter_code>np.array([1,2,3], dtype= str)
#Par exemple, ce tableau est un tableau de chaînes de caractères
np.array([1,2,3], dtype= float)
# Alors que celui-ci est un tableau de flottants
np.array([1000,2,3], dtype= np.int8)
np.array([1,2,3], dtype= np.float32)<jupyter_output><empty_output><jupyter_text>On crée un tableau monTableau<jupyter_code>monTableau = np.array([32,45,68,54])
monTableau<jupyter_output><empty_output><jupyter_text>Ce tableau a différents attributs<jupyter_code># Longueur du tableau (pour une matrice, le nombre de lignes)
len(monTableau)
# la dimension du tableau (nbLignes, nbColonnes)
monTableau.shape
#le type d'éléments qu'il contient
monTableau.dtype
# accéder au i-ème élément d'un tableau : monTableau[i]
monTableau[0]
# accéder aux i premiers éléments : monTableau[0:i] ou monTableau[:i]
monTableau[:2]
# accéder aux éléments entre les indices i et j (i inclus, j exclu): monTableau[i:j]
monTableau[1:3]<jupyter_output><empty_output><jupyter_text>J'aimerai générer un tableau de nombres aléatoires<jupyter_code># Génère un tableau de 5 entiers aléatoires entre 0 et 10
monTableau = np.random.randint(0,10,5)
monTableau = np.array([4,0,6,8,5])
monTableau<jupyter_output><empty_output><jupyter_text>J'aimerai que monTableau soit trié...<jupyter_code>np.sort(monTableau)<jupyter_output><empty_output><jupyter_text>Oui, mais en décroissant...<jupyter_code>-np.sort(-monTableau)<jupyter_output><empty_output><jupyter_text>Quelle est sa valeur minimale?<jupyter_code>np.min(monTableau)<jupyter_output><empty_output><jupyter_text>Et on la trouve à quel indice?<jupyter_code>np.argmin(monTableau)<jupyter_output><empty_output><jupyter_text>Quelle est sa valeur maximale?<jupyter_code>np.max(monTableau)<jupyter_output><empty_output><jupyter_text>Et on la trouve à quel indice?<jupyter_code>np.argmax(monTableau)<jupyter_output><empty_output><jupyter_text>Quelle est sa moyenne?<jupyter_code>np.mean(monTableau)
np.average(monTableau)
monTableau<jupyter_output><empty_output><jupyter_text>Percentile<jupyter_code>np.percentile(monTableau, 50)<jupyter_output><empty_output><jupyter_text>Filtrer certaines valeurs du tableau<jupyter_code>monTableau[monTableau<5]<jupyter_output><empty_output><jupyter_text>Quelle est sa variance? Son écart-type?<jupyter_code>np.var(monTableau)
np.std(monTableau)<jupyter_output><empty_output><jupyter_text>Définition simplifiée de tableau<jupyter_code>print(np.array([0.]*10)) # crée un tableau de 10 zéros
print(np.array([1.]*8)) # crée un tableau de 8 éléments tous égaux à 1
print(np.array([8.]*9)) # crée un tableau de 9 éléments tous égaux à 8
print(np.array([2*k+1 for k in range(17)])) # tableau des impairs jusqu'à 33<jupyter_output>[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[1. 1. 1. 1. 1. 1. 1. 1.]
[8. 8. 8. 8. 8. 8. 8. 8. 8.]
[ 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33]<jupyter_text>Équivalent à<jupyter_code>print(np.zeros(10)) # crée un tableau de 10 zéros
print(np.ones(8)) # crée un tableau de 8 fois 1
print(8*np.ones(9)) # crée un tableau de 9 fois 8
print(np.arange(1, 35, 2)) # tableau des impairs jusqu'à 33<jupyter_output>[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[1. 1. 1. 1. 1. 1. 1. 1.]
[8. 8. 8. 8. 8. 8. 8. 8. 8.]
[ 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33]<jupyter_text>Concaténation de deux tableaux<jupyter_code>num = np.array(['n','u','m'])
py = np.array(['p','y'])

conc = np.concatenate([num,py]) # tableau composé des lettres de num et des lettres de py

conc<jupyter_output><empty_output><jupyter_text>Opération sur des tableaux<jupyter_code>a = np.array([1]*5+[2]*10, dtype=np.int32)

print("a = ", a)
print("a + a = ",np.add(a,a))
print("4*a - a = ",np.subtract(4*a,a))
print("a / 4 = ",np.divide(a,4*np.ones(len(a))))<jupyter_output>a =  [1 1 1 1 1 2 2 2 2 2 2 2 2 2 2]
a + a =  [2 2 2 2 2 4 4 4 4 4 4 4 4 4 4]
4*a - a =  [3 3 3 3 3 6 6 6 6 6 6 6 6 6 6]
a / 4 =  [0.25 0.25 0.25 0.25 0.25 0.5  0.5  0.5  0.5  0.5  0.5  0.5  0.5  0.5
 0.5 ]<jupyter_text>Et en plusieurs dimensions? On peut définir des matrices?<jupyter_code>A = np.array([[1,2,3],[4,5,6],[7,8,9]])
print("A =", A)
B = np.array([1,2,3])
print("B = ", B)<jupyter_output>A = [[1 2 3]
 [4 5 6]
 [7 8 9]]
B =  [1 2 3]<jupyter_text>Multiplication matricielle<jupyter_code>np.multiply(A, B)
A * B<jupyter_output><empty_output><jupyter_text>Produit de deux tableaux/matrices<jupyter_code>np.dot(A, B)<jupyter_output><empty_output><jupyter_text>Produit scalaire<jupyter_code>np.vdot(B, B)<jupyter_output><empty_output><jupyter_text>Transposer une matrice<jupyter_code>A.transpose()<jupyter_output><empty_output><jupyter_text>Extraire sa diagonale<jupyter_code>np.diag(A)<jupyter_output><empty_output><jupyter_text>Matrice identité<jupyter_code>np.eye(4,4)<jupyter_output><empty_output><jupyter_text>Définir un espace continu<jupyter_code>np.linspace(-1,1,20) # 20 points entre -1 et 1<jupyter_output><empty_output><jupyter_text>Filtrer des valeurs respectant une condition<jupyter_code>a = np.arange(1,15,1)

np.where(a>5) # rend les indices qui vérifient la condition "est supérieur à 5"
a[np.where(a>5)] # rend les valeurs qui vérifient la condition précédente<jupyter_output><empty_output><jupyter_text>Mettre à l'échelle<jupyter_code>tab = np.array([10, 12, 15, 15,
                18, 19, -15, -16,
                -14,-18,-15,-16])

tab.reshape(3,4) # transforme le tableau initial en une matrice de 3 lignes et 4 colonnes
print("A = ", A)
np.array(A.reshape(-1,1)) # transforme la matrice A en un tableau<jupyter_output>A =  [[1 2 3]
 [4 5 6]
 [7 8 9]]<jupyter_text>Des fonctions et des constantes en maths<jupyter_code>np.sin(0) # rend sinus(0), la fonction sinus en 0
np.cos(np.pi) # rend cosinus en pi<jupyter_output><empty_output><jupyter_text>Import/ExportCréez un fichier texte "loadtxt.txt" dans votre répertoire de travail, et copier le texte suivant:1,  2,  3,  5,  6,  8, 74,  5,  5<jupyter_code>np.loadtxt("loadtxt.txt", #l'adresse du fichier
           delimiter=',', # le délimiteur de texte
           dtype=np.int) #le type du tableau à importer<jupyter_output><empty_output><jupyter_text>La fonction genfromtext prend en charge les manquants, essayez de rajouter une vigule dans un fichier "genfromtxt.txt", par exemple:1, 2, 3, 5, 6, 8, 74, 5,, 5<jupyter_code>np.genfromtxt("genfromtxt.txt", #l'adresse du fichier
           delimiter=',', # le délimiteur de texte
           dtype=np.int) #le type du tableau à importer<jupyter_output><empty_output><jupyter_text>Ok, c'est fini pour numpy! Petit test, que font ces fonctions?<jupyter_code>def enigma():
    tab = np.array([41,16,10,8,1,50])
    position = np.argmin(tab)
    tab = np.sort(tab)
    return np.min(tab)+tab[position]

#print("enigma : ", enigma())

def secret():
    tab = np.array([k*5 for k in range(10)])
    tab = tab[tab<25]
    return np.mean(tab)+len(tab)

#print("secret : ", secret())

def randomness():
    alea = np.random.randint(1,30,200)
    sup = alea[np.where(alea>10)]
    return np.min(sup)

#print("randomness :", randomness())

def matr():
    mat = np.arange(10,19,1).reshape(3,3)
    upright =  np.array([[1,0,0],[0,0,0],[0,0,0]])
    mat = mat - np.multiply(np.diag(mat),np.eye(3,3)-upright)
    return mat

#print("matr rend :", matr())

def maths():
    tour = np.linspace(0,2*np.pi,100)
    val = np.sin(tour)
    return tour[np.argmax(val)]

#print("maths rend :", mystere())<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1444794952681388, 'fraction_numerical': 0.0555205047318612, 'mean_word_length': 5.402261712439419, 'pattern_counts': {'":': 0, '<': 134, '<?xml version=': 0, '>': 135, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 7, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '34', 'dir': 'jupyter-structured-clean-dedup', 'id': '521062', 'license': 'MIT', 'n_tokens_mistral': 3606, 'n_tokens_neox': 3338, 'n_words': 762, 'path': '6.numpy/Numpy.ipynb', 'repo_name': 'llesoil/modelisation_des_problemes_scientifiques-', 'size': '7925'}