Opérateurs logiques¶

En python, les deux valeurs logiques sont True et False (avec des majuscules).

In [14]:
(1 == 1), (1 == 2)
Out[14]:
(True, False)

Mot-clef is¶

On peut tester la valeur d'une variable booléenne avec le mot-clef is. L'opérateur == fonctionne aussi mais c'est moins propre.

In [15]:
(1 == 1) is (2 == 2)
Out[15]:
True

Négation¶

On peut prendre la négation d'une valeur booléenne avec not

In [16]:
not(True)
Out[16]:
False
In [17]:
L = [1, 2, 3, 4, 5]
while not(L == []):
    print(L.pop())

5
4
3
2
1

Opération ET et OU¶

L'opération logique ET s'écrit and et l'opération logique OU s'écrit or.

In [18]:
for i in [True, False]:
    for j in [True, False]:
        print(i, " ET ", j, " = ", i and j)

True  ET  True  =  True
True  ET  False  =  False
False  ET  True  =  False
False  ET  False  =  False
In [19]:
for i in [True, False]:
    for j in [True, False]:
        print(i, " OU ", j, " = ", i or j)

True  OU  True  =  True
True  OU  False  =  True
False  OU  True  =  True
False  OU  False  =  False

Retour sur les fonctions¶

Paramètre optionnel¶

Dans la définition d'une fonction, on peut préciser des paramètres optionnels. Ils sont définis par la syntaxe param=defaut où param est le nom du paramètre, et default est la valeur du paramètre, lorsqu'il n'est pas donné.

Attention : les paramètres obligatoires doivent être specifiés avant les paramètres optionnels.

In [20]:
def decomposition(x, base=10):
    r = x
    L = []
    while r != 0:
        L.insert(0, r % base)
        r //= base
    return L

print(decomposition(1245, 10))
print(decomposition(1245))
print(decomposition(1245, 100))
print(decomposition(1245, 2))

[1, 2, 4, 5]
[1, 2, 4, 5]
[12, 45]
[1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1]

Passage par valeur¶

Pour la plupart des types de données (notamment les entiers, flottants, chaînes de caractères), la valeur du paramètre en entrée d'une fonction est copié en début d'exécution de la fonction. Ainsi, si la valeur du paramètre est modifiée dans la fonction, elle reste la même hors de la fonction.

Par exemple :

In [21]:
def incremente(x):
    x = x + 1
    return x

x = 0
y = incremente(x)
print(x)
print(y)

0
1

Passage par adresse¶

Pour d'autres types de données comme les listes, c'est l'adresse mémoire de l'objet qui est copié, de sorte que l'on peut appliquer des fonctions sur l'objet afin de le modifier.

Par exemple :

In [31]:
def ajoute(L, x):
    L.append(x)
    return L

L = []
print(L)
M = ajoute(L, "a")
print("L =", L)
print("M =", M)

[]
L = ['a']
M = ['a']

Bibliothèque math¶

Python permet de charger des bibliothèques, c'est-à-dire un ensemble d'objets et de fonctions qui ne sont pas de base dans le langage.

On a déjà vu la bibliothèque random qui permet de charger la fonction randint.

La bibliothèque math permet de charger des fonctions et des nombres particuliers. Par exemple :

In [23]:
from math import ceil, floor

x = 0.5
print(floor(x), ceil(x))

0 1
In [24]:
from math import sin, cos, pi

print(pi)
print(cos(pi/3), sin(pi/3))

3.141592653589793
0.5000000000000001 0.8660254037844386

On remarque que la bibiothèque ne manipule pas les valeurs exactes.

In [25]:
from math import sqrt

x = sqrt(2)
print(x)

1.4142135623730951
In [26]:
from math import gcd

print(gcd(21, 49, 77))

7

Affichage graphique¶

La bibliothèque matplotlib¶

On utilise la bibliothèque matplotlib, et très fréquemment le module pyplot. Pour cela, on peut taper :

import matplotlib.pyplot as plt

Cela crée un objet nommé plt qui nous sert à créer des graphiques. Plus précisément, on peut voir plt comme un agrégateur de graphiques. On lui ajoute petit à petit des figures que l'on affichera au moment voulu.

Pour plus d'informations, suivre le lien https://matplotlib.org/stable/index.html

Les fonctions plot et show de matplotlib.pyplot¶

La fonction plot permet d'afficher les données relatives à des points dans le plan. Plus précisément, si X = [x1, x2, ..., xn] et Y = [y1, y2, ..., yn] sont les listes des abscisses et des ordonnées des points à tracer, alors on peut exécuter la fonction

plt.plot(X, Y)

pour ajouter ces points au graphique. Ensuite, pour afficher le graphique on utilise la fonction show :

plt.show()
In [27]:
import matplotlib.pyplot as plt

annees = [i for i in range(2011, 2022) ]
temperatures = [13.6, 12.8, 12.4, 13.8, 13.6, 13.1, 13.4, 13.9, 13.7, 14.1, 12.9]

plt.plot(annees, temperatures)
plt.show()

Style¶

On peut changer le style de l'affichage :

In [28]:
# plt.plot(annees, temperatures, 'bo')  # b : blue, o : cercle  
# plt.plot(annees, temperatures, 'r+')  # r : red, + : plus
# plt.plot(annees, temperatures, linewidth=5)
# plt.plot(annees, temperatures, linestyle='dashed')
plt.plot(annees, temperatures, '-')

plt.show()

Superposition¶

On peut également superposer des graphiques

In [29]:
import matplotlib.pyplot as plt

annees = [i for i in range(2010, 2022) ]
temperatures_paris = [11.8, 13.7, 12.7, 12.1, 13.6, 13.4, 12.9, 13.4, 13.8, 13.6, 14.3, 12.8]
temperatures_marseille = [14.8, 16.2, 15.8, 15.2, 16.8, 16.3, 16.4, 16.2, 17, 16.4, 16.5, 15.9]

plt.plot(annees, temperatures_paris, color='blue')
plt.plot(annees, temperatures_marseille, color='red')
plt.show()

Tracer des fonctions¶

Pour tracer une fonction "usuelle" $f : [a, b] \to \mathbb{R}$ avec matplotlib.pyplot, une idée est de calculer les valeurs de $f(x)$ pour $x$ parcourant $[a, b]$ avec un petit pas.

Par exemple, si on souhaite tracer la fonction $f : x \mapsto x^2$ entre $-2$ et $2$, on va diviser l'intevalle en pas de $0.01$, puis calculer les $f(x)$ pour les valeurs $x = -2$, $x=-1.99$, $x=-1.98$, ..., $x=1.99$, $x=2$.

In [30]:
import matplotlib.pyplot as plt

a, b = [-2, 2]
X = [a + 0.01 * i for i in range(401)]
Y = [x**2 for x in X]

plt.plot(X, Y)
plt.show()
In [ ]: