Les commandes incontournables en Python à réviser pendant les vacances

Les vacances : le meilleur moment pour faire un point sur les maitères que l’on a pu parfois un peu négliger pendant l’année. Voici donc un récap de l’essentiel des commandes Python dont il faut s’assurer une bonne maîtrise afin d’aborder une nouvelle année sereinement. On rappelle que l’informatique est la matière avec la meilleure rentabilité (temps passé à travailler / points gagnés).

Lire plus : Python, les bases pour réussir en prépa ! 

Python :  les commandes essentielles pour les simulations en probabilités  

(après avoir réalisé l’importation : import numpy.random as rd )

• rd.random() : Cette commande simule une loi uniforme sur [0,1]. Car en effet cela va retourner un réel aléatoirement entre 0 et 1 

De plus on peut remarquer que des opérations telles que  : rd.random() * 4 – 1 : vont simuler une loi uniforme sur [-1,3]. Car va multiplier par 4 le réel entre 0 et 1 et lui soustraire 1. Finalement cela donnera un réel entre -1 et 3 

Il est important de bien comprendre le mécanisme qui se trouve derrière cette commande car elle peut servir pour de la modélisation plus complexe et réfléchie 

• rd.uniform(a,b) : Plus simplement cela va simuler une variable uniforme sur [a,b]

• rd.randint(a,b) : Simule une variable uniforme sur [|a,b-1|]. C’est la soeur de la commande random mais spécialement pour les entiers. Cette commande renvoie un entier naturel entre a et b-1

• rd.binomial(n,p) : Permet de simuler une variable suivant une loi Binomiale de paramètre n,p

• rd.binomial(1,p) : Permet de simuler une variable suivant une loi de Bernoulli. Car en effet elle simule du Binomiale de paramètre 1,p. Or d’après le cours on rappelle qu’une Binomiale est seulement une succession de plusieurs variables de Bernoulli identiques et indépendantes 

• rd.geometric(p) : Cette commande permet de simuler une variable suivant une loi géométrique de paramètre p. La loi géométrique modélise le nombre de tentatives nécessaires avant de réussir une première fois dans une série d’essais indépendants, chacun ayant une probabilité p de succès.

• rd.exponential(1/lambda) :  Attention pièges❗: Le paramètre entrée est l’inverse de celui de la loi à simuler. Cette commande simule une variable suivant une loi exponentielle de paramètre λ.

• rd.normal(m,sigma) :  Attention pièges❗: Le paramètre sigma n’est pas au carré à la différence de celui qui est à simuler. Cette commande permet de simuler une variable suivant une loi normale avec une moyenne m et une variance de sigma**2

• rd.poisson(lambda) : Cette commande permet de simuler une variable suivant une loi de Poisson de paramètre lambda

• rd.gamma(nu) : Cette commande permet de simuler une variable suivant une loi gamma de paramètre nu. La loi gamma est une généralisation de la loi exponentielle. 

Lire plus : Maîtriser Python en prépa ECG : les dix commandements

Comment créer une variable qui est liste de r entiers simulations sur Python ?

(avec l’importation from numpy.random import *)

** On dit de variables suivant une loi __, mais on dira ici par abus de langage que la variable est de loi ___ **

Les commandes Numpy à maîtriser sur Python

Dans cette bibliothèque qui est la plus souvent utilisée, quelques commandes sont parfois oubliées par les étudiants alors que pourtant seraient bien pratiques dans des exos types python type Hec ou bien même seulement lorsqu’il s’agit de mobiliser une réflexion informatique pour construire un programme

• np.floor(x) : Donne la partie entière de x. Cela peut s’appliquer à une liste et cela retourne la partie entière de chaque élément de la liste. On le retrouve dans des exos de probas et peut être un allié incontournable.

• np.array([A,B,C]) : Cette commande crée un vecteur Numpy à partir d’une liste ou une liste de listes. Cela permet de construire des matrices ou des vecteurs simples que l’on peut « plot » pour construire un graphique. Attention à ne pas confondre avec np.arange

• np.arange(a, b, r) : Génère des valeurs dans une plage donnée, avec un pas spécifique. Ici on commence à a puis génère toutes les valeurs jusqu’à b avec un pas de c. Cela permet de créer un vecteur très long dont les éléments ont une suite logique entre elles

Lire plus : PYTHON : les bases pour réussir en prépa

Quelques commandes Python pratiques pour les Listes

Il est nécessaire de savoir différencier les listes classiques des listes numpy (aussi appelées vecteurs)

• L.append(x) : Permet d’ajouter un élément x en bout de liste. Cette commande est une des plus utilisée car c’est en général grâce à elle que l’on va construire des listes pour ensuite réaliser des opérations dessus. À noter que pour construire des listes il existe une alternative : créer un vecteur de n 0 ou n 1 puis réaliser des opérations sur chaque termes en balayant la liste avec les commandes « np.zeros(n) » et la création d une boucle for puis L[i] = …

• L.count(x) : Retourne le nombre de fois que l’élément x apparaît dans la liste L. Non exigible au programme mais largement utile pour alimenter une réflexion informatique sur des exos plus durs type Hec.

• del(L[i]) : Supprime l’élément à l’index i de la liste L. Rarement rencontré lors d’exos mais à ne jamais oublier

• x in L : Vérifie si l’élément x est présent dans la liste L. Cette commande va renvoyer un booléen True ou False. Mais il faut savoir que ce booléen peut être considéré par Python comme un chiffre 1 ou 0 et que donc il est possible de réaliser des opérations dessus

• sum(L) : Calcule la somme des éléments de la liste L. Plus rapide que de créer une boucle for ! Attention cette commande ne marche exclusivement QUE sur les listes !

Les commandes liées à la bibliothèque Matplotlib.pyplot

Pour créer des graphiques ou tracer des fonctions tu auras besoin de connaitre les quelques commandes suivantes de la bibliothèque matplotlib.pyplot. Vérifie que tu les connais bien !

• import matplotlib.pyplot as plt : Importe le module pyplot de matplotlib, essentiel pour tracer des graphiques.

• plt.plot(x, y) : Trace une ligne reliant les points définis par les listes x et y qui sont à définir auparavant sous forme de listes classiques ou vecteurs

• np.linspace(a,b,n) : On peut donc plot des vecteurs créés avec arange mais il existe aussi la commande linspace qui renvoie un vecteur contenant n coefficients en progression arithmétique, le premier étant le réel a et le dernier le réel b. 

⇒ Pour les fonctions, on pourra privilégier np.linspace() et pour les suites, np.arange().

• plt.scatter(x, y) : Crée un nuage de points avec les coordonnées définies par les listes x et y.

• plt.show() : La dernière commande que l’on a tendance à oublier à la fin d’un programme mais qui est pourtant essentielle

Conclusion sur le Python en vacances (mais pas que) 

Finalement en ayant revu toutes ces commandes soit classiques soit un peu plus niches et en étant sûr de bien les maîtriser, tu vas être capable de pouvoir réfléchir toi même à la résolution d’exos plus complexes. N’oublie pas que pour réussir en info en prépa tu dois absolument comprendre tous les outils que tu as en ta possession pour réaliser le meilleur programme qui répond à la question ! 😉