Prérequis en Python

Le niveau de Python supposé et mobilisé pour cet enseignement est celui attendu à l’issue de l’enseignement SMI3U13 - Algorithmique et programmation 1 de L2 (voir la page du parcours).

En particulier, vous devriez vérifier que chacun des points suivants est maîtrisé. Chaque tâche ne devrait vous prendre que quelques minutes (ou même dizaines de secondes); et les programmes demandés ne représentent que quelques lignes de Python chacun (généralement moins de 4).

Il s’agit de vous auto-évaluer. Si vous vous sentez en confiance et qu’une question vous parait trop simple, ignorez-la. Si par contre, malgré vos efforts, vous avez un doute ou une difficulté dites-le sur le forum !

Tout ce qui figure dans cette fiche et qui n’a pas été signalé sera supposé connu.

Vous pouvez vous aider d’un outil comme Python Tutor pour visualiser l’exécution d’un programme pas à pas.

Calculs, affectations, tests, boucles et types numériques

Vous devriez savoir prédire et expliquer le type et la valeur de x à l’issue de chacun des extraits de code suivants.

x = 2*3

x = 2**3

x = 2**.5

x = 7/3 # ici, on ne vous demande pas de deviner le dernier chiffre

x = 7//3

x = 7%3

x = 1
y = 2
y = x
x = y

x = 0
for i in range(10):
    x += 1

x = 0
for i in [4,2,1]:
    x += i

x = 100
while x >= 7:
    x = x-7

x = 1
while x > 1:
    x = 0

x = 1
x = x == 1

x = 1 == 1.0

Vous devriez aussi savoir expliquer pourquoi

(10**100+1)-10**100 == 1

mais

(10.0**100+1)-10.0**100 == 0.0

et (au moins vaguement) pourquoi:

(2**.5)*(2**.5)

ne donne pas 2.0.

Fonctions et portée

• Écrivez une fonction delta(a,b,c) qui renvoie le discriminant du polynôme $ ax^2+bx+c $ (en supposant que a, b, c sont des nombres flottants).

• Vous devriez deviner la valeur de x après:

  def double(x):
      print(x)
      return 2*x
  x = double(double(double(2)))
  

  et aussi prévoir ce qui est affiché en cours de route.

• Vous devriez comprendre pourquoi, après le programme suivant, x vaut 0:

  x = 0
  def incr(x):
      x = x+1
  for i in range(10):
      incr(x)
  

• Vous devriez savoir expliquer les comportements (différents) des deux programmes suivants :

  def a():
    return "a"
  print(a())
  

  et

  def a():
    print("a")
  print(a())
  

• Si on vous demande d’écrire une fonction truc(n) qui renvoie le plus petit entier naturel r tel que 7r³-2r+1$ > $n, pourquoi est-ce que le programme suivant n’est pas bon ?

  def truc(n):
      r = 0
      while 7*r**3-2*r+1 <= n:
          r += 1
  

• Après

  def f(x,n,a=1):
      if n <= 0:
          return a
      return f(x,n-1,x*a)
  

  que vaut f(2,3) ?

• Si j’écris:

  def f(x):
      '''Renvoie la valeur absolue de `x` (si c’est un nombre entier ou flottant).'''
      if x<0:
          x = -x
      return x
  

  à quoi sert la première ligne du corps de la définition ?

Séquences : tableaux, n-uplets, chaînes

Vous devriez savoir prédire et expliquer le type et la valeur de x à l’issue de chacun des extraits de code suivants.

l = [1, 2, 3]
x = l[1]

s = "abc"
x = l[1]

l = [1]
x = l[0] == l

s = "a"
x = s[0] == s

l = [1, 2, 3]
x = l[-1]

l = list(range(10))
x = l[-1]

l = list(range(10))
x = l[1:9]

l = list(range(10))
x = l[1:1]

l = list(range(10))
x = l+l

l = list(range(10))
x = len(l)

x,y = 1,2
y,x = x,y

x = 1,2
x,y = x

x = []
for i in range(5):
    x = x+[i**2]

x = []
for i in range(5):
    x.append(i**2)

x = [i**2 for i in range(5)]

x = [i**2 for i in range(5) if i%2 == 0]

Dictionnaires

Que fait la fonction suivante ?

def f(l):
    d = {}
    for x in l:
        if x in d:
            d[x] = d[x] + 1
        else:
            d[x] = 1
    return d

Utilisation des modules

• Comment calculer (une valeur approchée de) $ \mathrm{sin}(42°) $ en utilisant la bibliothèque standard de Python ?

• Écrivez une fonction de6() qui renvoie un nombre au hasard entre 1 et 6 à chaque fois qu’on l’appelle (pas comme ça).

Exceptions

Expliquez ce qui se passe lorsqu’on lance:

l = list(range(10))
i = 0
x = 0
while i <= len(l):
    x = x + l[i]

Que calcule (intuitivement) la fonction suivante ?

def f(x):
    import math
    try:
        return math.sqrt(x)
    except ValueError:
        return 0.0

Programmation objet

Chacune des principales constructions mathématiques qu’on étudiera sera traduite en définissant une classe Python. Celle-ci sera munie de méthodes réalisant les opérations qui définissent la structure étudiée.

Il faut donc à minima savoir comment on définit et utilise une classe en Python.

Ping pong

Définissez une classe PingPong() munie de deux méthodes ping() et pong(), et telle que, après p = PingPong() :

• p.ping() (resp. p.pong()) affiche ping (resp. pong) si c’est la première fois qu’on appelle une de ces deux méthodes, ou bien si on a appelé l’autre juste avant ;
• chaque méthode affiche raté, si on l’a déjà appelée avant, sans appeler l’autre depuis.

Par l’exemple :

p = PingPong()
p.ping()
p.pong()
p.ping()
p.pong()

doit afficher

ping
pong
ping
pong

et

p = PingPong()
p.pong()
p.pong()
p.pong()
p.ping()

doit afficher

pong
raté
raté
ping

Un peu de tout

• Que vaut l après le code suivant?

  class Jeton:
      def __init__(self):
          self.x = False
      def tourne(self):
          self.x = not self.x
          return self.x
  j = Jeton()
  l = [j.tourne() for i in range(5)]
  

• Ajoutez à la classe ci-dessus une méthode lance(), qui change la valeur de l’attribut x, en la tirant au hasard parmi les deux valeurs True et False, et renvoie cette valeur.

• Modifiez la classe (possiblement en lui ajoutant les attributs et méthodes que vous voudrez), pour qu’on dispose d’une nouvelle méthode frequence() qui renvoie la proportion des appels à lance() qui ont renvoyé True (et renvoie une exception quand cette fréquence n’est pas définie).