Introduction à Python¶
Variables¶
python permet de créer des variables booléennes, entières, réelles, chaines de caractère, ... de la manière la plus simple. Pas besoin de connaitre le nom des types, celui-ci est défini à l'affectation.
x = 1
type(x)
y = 3.1415
type(y)
z = True
type(z)
s = 'Hello'
type(s)
t = (1 , 1)
type(t)
a = [ 1, 2, 3 ]
type(a)
print(x)
print(y)
print(x,y,z)
print('{:>10}{:>10}{:>10}'.format('x','y','z'))
print('{:>10}{:>10}{:>10}'.format(x,y,z))
Notez que contrairement au C++, le type d'une variable peut changer par affectation. Une variable python est juste un nom qui pointe vers un objet. L'affectation le fait pointer vers un autre objet. Par exemple, pour x qui est jusqu'ici de type int
x = 3.14
type(x)
Décisions¶
Les décisions en python se font via l'instruction if, elif, else corresponant au if, else if, else du C++. L'expression booléenne testée est suivie de :, la branche de code à exécuter est écrite sur la/les lignes suivantes indentées.
x = 1.4
if x < 0:
print(x,'est négatif')
elif x == 0:
print(x,'est nul')
else:
print(x,'est positif')
Notez que la définition des blocs de code se fait par indentation, contrairement au C++ qui utilise les accolades {...}
x = 1.4
if x < 0:
print(x,'est négatif')
elif x == 0:
print(x,'est nul')
else:
print(x,'est positif')
if x > 2:
print('et plus grand que 2')
print('ça fait beaucoup')
print('mais pas trop')
Boucles¶
python dispose de boucles while et for mais pas de boucle do ... while. La syntaxe des boucles while est quasi identique à celle des décisions ci-dessus
x = -5
while x < 0:
print(x)
x += 1
print('fin de boucle: x vaut',x)
La boucle for sert uniquement à itérer sur les éléments d'une séquence (tableau, liste, caractères d'une chaine), similairement à la syntaxe for(auto c : s) du C++ par exemple.
s = "Hello"
for c in s:
print(c)
Si l'on veut écrire l'équivalent du boucle
for(int i = 0; i < N; ++i)
en C++, il faut créer une séquence contenant les entiers de 0 à N-1. On utilise pour cela range(0,N).
for i in range(0,5):
print(i,i**2)
for i in range(0,10,2):
print(i,i**3)
for i in range(5,0,-1):
print(i,i**4)
Fonctions¶
python permet de définir des fonctions avec le mot clé def
def hello(name, loud):
if loud:
print('HELLO', name.upper(), '!')
else:
print('Hello', name)
hello('Adam',False)
hello('Bob',True)
La fonction précédente n'a pas de valeur de retour. Le mot clé return permet d'en retourner une ... ou plusieurs
def somme(a,b):
s = a+b
return s
x = 1
y = 2
s1 = somme(x,y)
print('somme = ',s1)
def sommeEtDiff(a,b):
s = a+b
d = a-b
return s,d
s2,d2 = sommeEtDiff(x,y)
print('somme = {0} et difference = {1}'.format(s2,d2))
Les paramètres peuvent avoir des valeurs par défaut
def puissance(exp1,exp2,base=10,step=1):
for exp in range(exp1,exp2,step):
print(base**exp)
puissance(0,3) # exp1 = 0 et exp2 = 3
puissance(0,3,2) # exp1 = 0, exp2 = 3 et base = 2
Il est aussi possible de passer les paramètres dans le désordre en spécifiant leurs noms.
puissance(0,10,step=3) # exp1 = 0, exp2 = 10 et step = 3
puissance(base=2,exp2=10,exp1=0,step=3)
Tableaux¶
Les tableaux les plus utilisés sont de type list, même s'ils sont en pratique mis en oeuvre sous la forme de tableaux redimensionable, similairement à la classe vector en C++.
T = [ 6, 3, 5, 1, 2, 4 ]
print(T)
type(T)
Parcourir tous les éléments du tableau se fait avec la boucle for
for t in T:
print(t)
On dispose d'un accès par indice avec les crochets []. Parcourir tout les indices du tableau utilise la séquence range vue plus haut et la fonction len qui retourne la taille de la liste
for i in range(0,len(T)):
T[i] = T[i]**2
print(T)
Si nécessaire, la fonction enumerate permet un accès simultané aux indices et aux éléments
for i, t in enumerate(T):
print("T[",i,"] =",t)
Les tableaux sont redimensionables. En particulier on dispose de la méthode append qui correspond à push_back en C++.
T2 = []
for t in T:
T2.append(t+1)
print(T2)
Mais il y a une syntaxe plus élégante en python pour écrire la boucle ci-dessus. Elle sera utilisée dans ce cours.
T3 = [ t+1 for t in T ]
print(T3)
Enfin, on peut facilement créer des sous-tableaux en en prenant une tranche (slice)
print(T)
print(T[1:4])
print(T[:2],T[2:])
Librairies¶
De très nombreuses librairies étendent les fonctionalités de python. Pour les utiliser, on utilise le mot clé import ou import ... as ... pour la renommer. Dans le cadre de ce cours, nous utiliserons essentiellement la librairie numérique numpy et celle de dessin de graphes 2d matplotlib .
Voyons comment dessiner le graphe d'une fonction sinus
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0,10*np.pi,200)
y = np.sin(x)
plt.plot(x,y)
plt.title('Fonction sinus')
plt.xlabel('x (radians)')
plt.ylabel('y = sin(x)')
plt.show()
Graphes¶
Une fonction particulièrement utile pour la suite est la possibilité d'afficher des graphes avec des échelles linéaires ou logarithmique pour chacun des axes.
x = np.linspace(0,100,11)
print(x)
x = np.logspace(0,2,11)
print(x)
x = np.logspace(0,7,50)
y = np.square(x)
z = np.power(x,3)
plt.plot(x,x,label='x')
plt.plot(x,y,label='x^2')
plt.plot(x,z,label='x^3',marker='.')
plt.legend()
plt.title('linear')
plt.show()
plt.loglog(x,x,label='x')
plt.loglog(x,y,label='x^2')
plt.loglog(x,z,label='x^3',marker='.')
plt.legend()
plt.title('loglog')
plt.show()
plt.semilogx(x,x,label='x')
plt.semilogx(x,y,label='x^2')
plt.semilogx(x,z,label='x^3',marker='.')
plt.legend()
plt.title('semilogx')
plt.show()
plt.semilogy(x,x,label='x')
plt.semilogy(x,y,label='x^2')
plt.semilogy(x,z,label='x^3',marker='.')
plt.legend()
plt.title('semilogy')
plt.show()
Nombres aléatoires¶
import random
random.random() # nombre aléatoire entre 0 et 1
random.randint(0,100) # entier aléatoire entre 0 et 100 (100 y compris)
random.uniform(0,100) # nombre aléatoire entre 0 et 100, distribution uniforme
T = np.random.uniform(0,10,100) # 100 nombres aléatoires entre 0 et 10
plt.stem(T,markerfmt=',',linefmt='black',basefmt='black')
plt.show()
|
© Olivier Cuisenaire, 2018 |