main.py

import numpy as np

# ===============================
# 1. Création, Manipulation et Calculs de Base avec ndarray
# ===============================

# Exercice 1.1 : Création de Tableaux

# Créez un tableau 1D contenant les nombres pairs de 0 à 20.
tab_pairs = np.arange(0, 21, 2)
print("Tableau de nombres pairs de 0 à 20 :\n", tab_pairs)

# Créez une matrice identité de taille 4x4.
mat_identite = np.eye(4)
print("\nMatrice identité 4x4 :\n", mat_identite)

# Générez un tableau 3D de shape (2, 3, 4) rempli de nombres aléatoires entiers entre 10 et 50.
tab_3d = np.random.randint(10, 51, size=(2, 3, 4))
print("\nTableau 3D (2,3,4) aléatoire entre 10 et 50 :\n", tab_3d)

# Exercice 1.2 : Calculs de Base

A = np.array([[1, 3], [5, 7]])
B = np.array([[2, 4], [6, 8]])

# A + B
print("\nA + B =\n", A + B)

# A - B
print("\nA - B =\n", A - B)

# A * B (produit élément par élément)
print("\nA * B (élément par élément) =\n", A * B)

# produit matriciel A . B
print("\nProduit matriciel A.B =\n", np.dot(A, B))

# moyenne de tous les éléments de A
print("\nMoyenne des éléments de A :", np.mean(A))

# ===============================
# 2. Indexation, Slicing et Modification
# ===============================

# Exercice 2.1 : Indexation et Slicing

M = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])

# Extrayez le sous-tableau [20, 30, 50, 60].
sub_tab = M[0:2,1:3]
print("\nSous-tableau [20,30,50,60] :\n", sub_tab)

# Extrayez la dernière colonne sous forme d'un tableau 1D.
last_col = M[:,2]
print("\nDernière colonne (1D) :\n", last_col)

# Inversez l'ordre des lignes de M.
M_inv = M[::-1,:]
print("\nM inversé (lignes inversées) :\n", M_inv)

# Exercice 2.2 : Modification

arr = np.zeros((4,4))

# Remplissez la première colonne avec 1.
arr[:,0] = 1
print("\nRemplir première colonne avec 1 :\n", arr)

# Remplacez la diagonale secondaire (haut droit à bas gauche) par 5.
np.fill_diagonal(np.fliplr(arr), 5)
print("\nDiagonale secondaire remplie par 5 :\n", arr)

# Remplacez tous les éléments supérieurs à 3 par leur carré dans un tableau aléatoire (5,5).
rand_arr = np.random.randint(1,10,size=(5,5))
print("\nTableau aléatoire avant modification :\n", rand_arr)
rand_arr[rand_arr > 3] = rand_arr[rand_arr > 3] ** 2
print("\nTableau après modification (x² si >3) :\n", rand_arr)

# ===============================
# 3. Opérations Vectorielles et Fonctions Universelles
# ===============================

# Exercice 3.1 : Opérations Vectorielles

x = np.array([1,2,3,4,5])
y = np.array([5,4,3,2,1])

# x² + y³
res1 = x**2 + y**3
print("\nx² + y³ = ", res1)

# produit scalaire x.y
prod_scal = np.dot(x,y)
print("\nProduit scalaire x.y = ", prod_scal)

# comparer x et y (x > y)
comp = x > y
print("\nx > y : ", comp)

# Exercice 3.2 : Fonctions Universelles

A = np.array([-2,-1,0,1,2])

# sinus sur A
sin_A = np.sin(A)
print("\nSinus(A) : ", sin_A)

# log naturel des valeurs absolues de A
log_A = np.log(np.abs(A))
print("\nLog(abs(A)) : ", log_A)

# indice valeur maximale d’un tableau 2D aléatoire (3x3)
rand_2d = np.random.randint(0,100,(3,3))
print("\nTableau 2D aléatoire :\n", rand_2d)
indice_max = np.argmax(rand_2d)
print("\nIndice valeur maximale : ", indice_max)

# Exercice 3.3 : Broadcasting

M = np.array([[1,2,3],[4,5,6],[7,8,9]])
v = np.array([1,0,-1])

# Multipliez chaque colonne de M par v
mult_col = M * v
print("\nChaque colonne de M * v :\n", mult_col)

# Ajoutez v à chaque ligne de M
add_line = M + v
print("\nM + v sur chaque ligne :\n", add_line)

# ===============================
# 4. Exercices Combinés (Avancés)
# ===============================

# Exercice 4.1 : Filtrage et Masques

data = np.random.randint(0,100,(10,10))

# Remplacez toutes les valeurs paires par 0 et impaires par 1
data_parite = np.where(data % 2 == 0, 0, 1)
print("\nPaires=0, impaires=1 :\n", data_parite)

# Extrayez toutes les valeurs supérieures à 50
sup_50 = data[data > 50]
print("\nValeurs > 50 :\n", sup_50)

# Moyenne des valeurs entre 20 et 80
between_20_80 = data[(data >= 20) & (data <= 80)]
mean_20_80 = np.mean(between_20_80)
print("\nMoyenne des valeurs entre 20 et 80 : ", mean_20_80)

# Exercice 4.2 : Manipulation de Shape

arr = np.arange(1,25)

# Redimensionnez en (6,4)
arr_6_4 = arr.reshape(6,4)
print("\narr en (6,4) :\n", arr_6_4)

# Aplatissez puis reconvertissez en (3,8)
arr_flat = arr_6_4.flatten()
arr_3_8 = arr_flat.reshape(3,8)
print("\narr aplati puis (3,8) :\n", arr_3_8)

# Échangez axes 0 et 1 d’un tableau 3D aléatoire (2,3,4)
arr_3d = np.random.randint(0,10,(2,3,4))
print("\nTableau 3D avant swapaxes :\n", arr_3d)
arr_swap = np.swapaxes(arr_3d,0,1)
print("\nAprès swapaxes 0 et 1 :\n", arr_swap)