Jupyter notebook Notes de cours/Introduction-1.ipynb

Path: Notes de cours/Introduction-1.ipynb

Views: ¹³²

Kernel: Python 3

Introduction à l'informatique et Python

Python comme (super) calculatrice

Les opérations de base sur les entiers

In [1]:

1 + 1

2

In [2]:

2 * 3

6

In [3]:

4 - 5

-1

Attention : il y a deux divisions différentes !

In [4]:

5 / 2 # Renvoie un flottant (cf ci-dessous)

2.5

In [5]:

5 // 2 # Renvoie le quotient dans la division euclidienne

2

In [6]:

5 % 2 # Renvoie le reste dans la division euclidienne

1

Notez qu'on utilise le symbole # (dièse) pour commenter la fin de la ligne, c'est-à-dire pour dire à l'interpréteur d'ignorer tout ce qui suit.

Attention : pour élever à une puissance, on n'utilise pas ^ mais **:

In [7]:

5 ** 2

25

In [8]:

5 ^ 2 # pour ceux qui comprennent : cette opération est le "xor bit-à-bit" (posez-moi la question ;-))

7

In [9]:

(5 * 3 + 2) * 4 # règles de priorité comme en maths

68

In [10]:

5 ** 1000

933263618503218878990089544723817169617091446371708024621714339795966910975775634454440327097881102359594989930324242624215487521354032394841520817203930756234410666138325150273995075985901831511100490796265113118240512514795933790805178271125415103810698378854426481119469814228660959222017662910442798456169448887147466528006328368452647429261829862165202793195289493607117850663668741065439805530718136320599844826041954101213229629869502194514609904214608668361244792952034826864617657926916047420065936389041737895822118365078045556628444273925387517127854796781556346403714877681766899855392069265439424008711973674701749862626690747296762535803929376233833981046927874558605253696441650390625

Les flottants

Les flottants (type float) sont les nombres à virgule de Python :

La virgule se note avec un point : 3.2 ;
Ce ne sont que des nombres avec un nombre fini de chiffres après la virgule ;
Ils sont représentés en binaire : certains opérations ne sont pas exactes.

In [11]:

1.3 + 3.2

4.5

In [12]:

2.3 * 3.4 # Arg!

7.819999999999999

In [13]:

2.4 - 3.5

-1.1

In [14]:

2.4 / 1.3

1.846153846153846

In [15]:

1.2 ** 2 # élévation d'un flottant (1.2) à une puissance entière 2

1.44

In [16]:

1.4 ** 2.4 # élévation à une puissance flottante : attention à la signification !

2.2423700574830967

In [17]:

2 ** .5 # racine carrée positive

1.4142135623730951

In [18]:

(-1) ** .5 # Python connaît les complexes !

(6.123233995736766e-17+1j)

Attention !

Pour Python, il y a $2$ types de nombres : les entiers (type int) et les flottants (type float, nombres à virgules avec un nombre fini de décimales). Notez la différence d'affichage :

In [19]:

2 * 3

6

In [20]:

2.0 * 3.0

6.0

Notez que si on mélange les deux types dans une addition ou multiplication, Python transforme tout en float :

In [21]:

2 * 3.2 # équivalent à 2.0 * 3.2, ou 3.2 * 2, ou ...

6.4

Autres opérations mathématiques

In [22]:

abs(-4) # valeur absolue

4

In [23]:

max(3, 5) # maximum

5

In [24]:

min(3, 5) #minimum

3

Programmation

Les variables et affectations

On peut définir des variables, et leur affecter une valeur, en utilisant le signe = :

In [25]:

a = 3
b = 5
a * b

15

Si on ré-affecte une variable, sa valeur précédente est perdue :

In [26]:

a = 3
b = 2
a = b * 3
a

6

L'affectation est une opération asymétrique : on met dans la variable à gauche du signe égal la valeur de l'expression à droite du signe égal.

Par exemple, l'expression x = x+1 n'est pas une équation à résoudre, mais signifie « mettre la valeur de l'expression x+1 dans la variable x » : on change donc la valeur de x.

In [27]:

x = 1
x = x + 1
x

2

Dans l'exemple suivant, complétez la valeur de a et b à chaque ligne (puis vérifiez que ça correspond en bas !) :

In [28]:

a = 3     # a vaut 3
b = 5     # a vaut 3  ; b vaut 5
a = b + 3 # a vaut ?? ; b vaut ??
b = a     # a vaut ?? ; b vaut ??
a = a + 1 # a vaut ?? ; b vaut ??
a , b     # Notation : couple (a,b)

(9, 8)

Attention ! Désolé de réinsister, mais le signe = est une affectation, de la droite vers la gauche, et sa signification est différente de sa signification en mathématiques !

Trois raccourcis plus ou moins utiles :

In [29]:

x += 1 # équivalent de x = x + 1
x -= 2 # équivalent de x = x - 2
u = v = 3 # équivalent de u = 3 puis v = 3
x,u,v

(1, 3, 3)

Écrire des programmes

Pour écrire un programme, on utilise le mot-clé def. Un programme en Python ressemble toujours à la construction suivante (notez l'indentation, obligatoire !) :

def mon_programme(arg1, arg2, arg3):
    <instructions> # affectations de variables, calculs, etc.
    return <resultat>

Dans l'exemple ci-dessus, mon_programme est le nom du programme, arg1, arg2 et arg3 sont ses arguments.

Essayez de bien comprendre l'exemple ci-dessous, qui calcule $a\times b - a - b$ , où $a$ et $b$ sont les deux arguments du programme :

In [30]:

def inutile(a, b):
    s = a + b
    m = a * b
    return m - s

Pour utiliser le programme inutile, on agit comme suit :

In [31]:

inutile(3, 5)

7

Tests et conditionnelle

On peut faire des tests avec la construction suivante :

if <condition>:
    <résultat si condition est vraie>
else:
    <résultat si condition est fausse>

Attention ! L'indentation (les quatre espaces avant <résultat si condition est vraie>) sont obligatoires.

In [32]:

a = 5
b = 3
c = 0
if a < b:
    c = a
else:
    c = b
c

3

Les différents tests sur les nombres :

x == y : x est égal à y
x != y : x est différent de y
x > y : x est strictement supérieur à y
x < y : x est strictement inférieur à y
x >= y : x est supérieur ou égal à y
x <= y : x est inférieur ou égal à y

In [33]:

3 < 5

True

In [34]:

4 <= 2

False

In [35]:

3 == 4

False

On peut combiner les tests avec les opérations booléennes and, or et not:

In [36]:

(3 < 4) and ((2 <= 1) or not (5 <= 6))

False

On peut déjà faire un programme qui renvoie le maximum de trois entiers $a$ , $b$ , $c$ :

In [37]:

def max3(a, b, c):
    if a > b and a > c:
        resultat = a
    elif b > a and b > c: # elif est la contraction de else: if ...
        resultat = b
    else: # tests inutiles, on sait que c est le plus grand
        resultat = c
    return resultat

In [38]:

max3(4, 6, 2)

6

Note : on peut écrire max3 différemment.

On peut imbriquer des if pour faire moins de tests ;
Le mot-clé return peut se trouver n'importe où : dès qu'on le rencontre, le programme est fini et on ne lit pas la suite

Convainquez-vous que vous comprenez bien la fonction ci-dessous ! Faites-bien attention à l'indentation.

In [39]:

def max3(a, b, c): # je réutilise le même nom, la fonction max3 est redéfinie
    if a > b:
        if a > c:
            return a
        return c # Ici, a > b et a <= c, donc c est le plus grand
    # A partir d'ici, on sait que a <= b
    if b > c:
        return b
    return c

In [40]:

max3(100, 3, 54) # ouf, ça marche toujours !

100

Les boucles

Boucle `for`

La boule for (pour) permet de répéter une série d'instruction un nombre pré-défini de fois :

for <var> in <liste de valeurs>:
    <instructions>

Par exemple, pour qu'une variable i parcoure tous les entiers de $1$ à $9$ , on écrit for i in range(1, 10) (oui, il faut mettre $10$ et pas $9$ !). Notez que si on commence à $0$ , on peut éviter de l'écrire : range(0, 10) ou range(10) signifient la même chose.

On calcule par exemple la somme des entiers jusqu'à $9$ , qui vaut $9(9+1)/2 = 45$ :

In [41]:

a = 0
for i in range(1, 10):
    a += i # Notation équivalente à "a = a + i"
a

45

Exemple

Le programme suivant combine la boucle for et les conditionnelles pour calculer la somme des diviseurs strict d'un entier $n$ :

In [42]:

def somme_diviseurs(n):
    s = 0
    for i in range(1, n):
        if n % i == 0:
            s += i
    return s

In [43]:

somme_diviseurs(17) # 17 est premier !

1

In [44]:

somme_diviseurs(60)

108

In [45]:

somme_diviseurs(6) # 6 est un nombre parfait

6

Boucle `while`

Une autre façon de faire des boucles est d'utiliser la boucle while.

while <condition>:
    <instruction>

On recalcule la somme des entiers jusqu'à 9 (pour être bien sûr de sa valeur !) :

In [46]:

a = 0
i = 1 # cette fois, on doit gérer la variable i nous-même
while i < 10: # ou i <= 9
    a += i
    i += 1
a

45

La boucle while permet, contrairement à for, de boucler sans savoir à l'avance combien de tours il y aura. Par exemple, le programme suivant calcule $\lfloor\sqrt x\rfloor$ :

In [47]:

def racine_carree_entiere(x):
    i = 0
    while i*i <= x:
        i += 1
    return i-1

racine_carree_entiere(17) # 4*4 < 17 mais 5*5 > 17

4

Autres types de données

Les listes

Le langage Python dispose d'une structure de donnée appelée liste, de type list. Une liste se note [élément1, élément2, ..., élémentn]. On peut mettre tout et n'importe quoi dedans.

In [6]:

l = [1, 2.4, "M1 MEEF"]
l

[1, 2.4, 'M1 MEEF']

In [7]:

l2 = [l, [2,4], 5.3]
l2

[[1, 2.4, 'M1 MEEF'], [2, 4], 5.3]

Pour accéder à l'élément numéro $i$ de la liste, on écrit l[i]. Attention, le premier élément est l'élément $0$ :

In [10]:

l[0], l[1], l[2], l2[1], l2[1][0]

(1, 2.4, 'M1 MEEF', [2, 4], 2)

In [13]:

l[2] # Boom!

'M1 MEEF'

La longueur d'une liste est donnée par len :

In [12]:

len(l)

3

On peut extraire une sous-liste, ou la parcourir « à l'envers » :

In [14]:

l3 = [1, 2, 3, 4, 5, 6, 7]
l3[2:5] # éléments numéro 2 (inclus) à 5 (exclu)

[3, 4, 5]

In [15]:

l3[-1], l3[-2] # dernier élément, avant-dernier-élément

(7, 6)

In [16]:

l3[-4:-2]

[4, 5]

In [17]:

l3[:2], l3[3:], l3[:] # équivalent à l3[0:2], l3[3:len(l3)], l3[0:len(l3)]

([1, 2], [4, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7])

De même, on peut modifier un élément d'une liste :

In [19]:

l[0] = 1000000
l

[1000000, 2.4, 'M1 MEEF']

In [20]:

l[-1] = "M2 MEEF (bientôt) !"
l

[1000000, 2.4, 'M2 MEEF (bientôt) !']

Attention à la copie des listes ! Comparez les deux comportements différents ci-dessous :

In [4]:

liste = [0, 1, 2, 3]
copie = liste
liste[2] = 100
copie[3] = 200
liste, copie

([0, 1, 100, 200], [0, 1, 100, 200])

In [5]:

liste = [0, 1, 2, 3]
copie = liste[:] # la sous-liste qui contient tous les éléments de liste
liste[2] = 100
copie[3] = 200
liste, copie

([0, 1, 100, 3], [0, 1, 2, 200])

Plus tordu (conclusion : faire attention) :

In [62]:

a = [1, 2, [3, 4]]
b = a
c = a[:]
a[0] = 0 # uniquement a & b modifiés
a[2][1] = 6 # a, b & c modifiés
a, b, c

([0, 2, [3, 6]], [0, 2, [3, 6]], [1, 2, [3, 6]])

Ajouter/supprimer des éléments à une liste :

In [66]:

l = [1, 2, 3, 2]
l.append(4) # ajoute 4 à la fin
l.remove(2) # enlève le premier "2" rencontré
l.insert(2, 2.5) # ajoute 1.5 en case 1
l

[1, 3, 2.5, 2, 4]

Autres fonctions :

In [ ]:

l.<tab>

Algorithmes sur les listes

Exemple : trouver l'élément maximal d'une liste

In [68]:

def max1(liste):
    m = liste[0] # premier élément
    for i in range(1, len(liste)):
        if liste[i] > m:
            m = liste[i] # on a trouvé notre nouveau champion
    return m

In [69]:

max1([3, 5, 12, 4, 3, 1])

12

En Python, on peut écrire la boucle plus simplement sans faire référence à l'indice i:

In [70]:

def max2(liste):
    m = liste[0]
    for elt in liste: # elt est un nom de variable choisi arbitrairement, et va successivement contenir tous les éléments de la liste
        if elt > m:
            m = elt
    return m

Note. La fonction max est prédéfinie en Python.

Les chaînes de caractères et la fonction `print`

In [71]:

s = "Ceci est un exemple"
s

'Ceci est un exemple'

In [72]:

len(s)

19

In [74]:

s[3]

'i'

In [76]:

s[3] = 'a'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-76-ea88b1e51ab8> in <module>()
----> 1 s[3] = 'a'

TypeError: 'str' object does not support item assignment

In [77]:

s + ' intéressant !'

'Ceci est un exemple intéressant !'

In [78]:

print(s)

Ceci est un exemple

In [79]:

print(2)

2

In [82]:

for c in s:
    print(c * 10)

CCCCCCCCCC
eeeeeeeeee
cccccccccc
iiiiiiiiii
          
eeeeeeeeee
ssssssssss
tttttttttt
          
uuuuuuuuuu
nnnnnnnnnn
          
eeeeeeeeee
xxxxxxxxxx
eeeeeeeeee
mmmmmmmmmm
pppppppppp
llllllllll
eeeeeeeeee

In [83]:

2*s

'Ceci est un exempleCeci est un exemple'

In [ ]: