Aller au contenu

Questions : fonctions

1. Fonctions et mathématiques

Question 1.1

Question

Parmi les 4 fonctions suivantes, lesquelles permettent de renvoyer le maximum des 2 paramètres ?

Fonction A :

def maximum(a,b):
    if a > b :
        resultat = a
    else :
        resultat = b
    return resultat

Fonction B :

def maximum(a,b):
    if a >= b :
        resultat = a
    else :
        resultat = b
    return resultat

Fonction C :

def maximum(a,b):
    if a > b :
        resultat = a
    if a < b :
        resultat = b
    return resultat

Fonction D :

def maximum(a,b):
    return a if a > b else b

  • A
  • B
  • C
  • D
  • A
  • B
  • C
  • D

Parmi les propositions, toutes conviennent sauf la C : lorsque les 2 paramètres sont égaux la C ne renvoie rien. La syntaxe de la D est particulière, mais usuelle en Python.

Question 1.2

Question

Parmi les 4 fonctions suivantes, lesquelles permettent de renvoyer la liste des valeurs de la table de multiplication d'un entier (c'est à dire les produits de cet entier par les entiers de 1 à 10) ?

Fonction A :

def table_multiplication(n):
    table = []
    for i in range(1,11):
        table.append(n*i)
    return table

Fonction B :

def table_multiplication(n):
    table = []
    for i in range(1,11):
        table = table + n*i
    return table_multiplication

Fonction C :

def table_multiplication(n):
    table = []
    for i in range(10):
        table.append(n*i)
    return table

Fonction D :

def table_multiplication(n):
    table = []
    for i in range(1,11):
        table = table + [n*i]
    return table

  • A
  • B
  • C
  • D
  • A
  • B
  • C
  • D

La proposition B essaie d'utiliser le symbole + entre une liste et un entier, ce qui provoque une erreur. Par ailleurs elle renvoie la fonction plutôt que la liste, ce qui ne répond pas à la question posée. La fonction C n'utilise pas les bons entiers : range(10)engendre les entiers de 0 à 9, et non de 1 à 10. Les fonctions A et D sont correctes.

2. Avec l'opérateur +

Question 2.1

Question

On donne la fonction suivante :

def plus(a, b)
    return a + b
Quel serait l'affichage produit par l'exécution de l'instruction suivante ?

print(plus(5, 6))
  • 11
  • 5 6
  • 56
  • Une erreur
  • 11
  • 5 6
  • 56
  • Une erreur

Lorsque les paramètres sont des nombres, le symbole + est un opérateur d'addition.

Question 2.2

Question

On donne la fonction suivante :

def plus(a, b)
    return a + b
Quel serait l'affichage produit par l'exécution de l'instruction suivante ?

print(plus('5', '6'))
  • 11
  • 5 6
  • 56
  • Une erreur
  • 11
  • 5 6
  • 56
  • Une erreur

Lorsque les paramètres sont des chaines de caractères, le symbole + est un opérateur de concaténation. L'affichage produit est la chaine de caractères '56' et non l'entier 56.

Question 2.3

Question

On donne la fonction suivante :

def plus(a, b)
    return a + b
Quel serait l'affichage produit par l'exécution de l'instruction suivante ?

print(plus('5', 6))
  • 11
  • 5 6
  • 56
  • Une erreur
  • 11
  • 5 6
  • 56
  • Une erreur

Lorsque les paramètres sont un entier pour l'un et une chaine de caractères pour l'autre, le symbole + n'a pas de signification. L'affichage produit est le message d'erreur : TypeError: cannot concatenate 'str' and 'int' objects

3. Tracés en boucle : des fonctions sans return

Les tracés suivants ont été réalisés dans un environnement Jupyter, à l'aide du module mobilechelonian qui permet d'utiliser l'essentiel des méthodes liées à la tortue. Pour exécuter les codes dans un notebook Jupyter, les instructions sont à précéder de :
from mobilechelonian import Turtle.

Dans un environnement standard on pourra utiliser le module turtle, avec quelques adaptations du code.

Question 3.1

Question

Parmi les programmes suivants, lequel permet de faire tracer à la tortue la figure ci-dessous ?

trois carrés

Programme A :

def carre(tortue):
    for nb_cote in range(3) :
        tortue.forward(100)
        tortue.left(90)

t = Turtle()
for nb_carre in range(4) : 
    carre(t)
    t.right(120) 

Programme B :

def carre(tortue):
    for nb_cote in range(4) :
        tortue.forward(100)
        tortue.left(90)

t = Turtle()
for nb_carre in range(3) : 
    carre(t)
    t.left(30) 

Programme C :

def carre(tortue):
    for nb_cote in range(4) :
        tortue.forward(100)
        tortue.left(90)

t = Turtle()
for nb_carre in range(3) : 
    carre(t)
    t.left(120) 

Programme D :

def carre(tortue):
    for nb_cote in range(4) :
        tortue.forward(100)
        tortue.left(90)

t = Turtle()
for nb_carre in range(3) : 
    carre(tortue)
    t.left(120) 

  • A
  • B
  • C
  • D
  • A
  • B
  • C
  • D

La fonction carre prend en paramètre une tortue. Cette fonction doit faire tracer 4 côtés (range(4)) et les angles d'un carré font 90°.
Lorsqu'on appelle cette fonction le paramètre prend pour valeur le nom de la tortue qui doit tracer le carré. Dans tous les programmes proposés, celle-ci s'appelle t. Chaque carré est l'image d'un autre par une rotation d'un tiers d'angle plein (360/3 = 120°). Le sens de cette rotation importe peu : t.right(120) aurait aussi convenu.

Question 3.2

Question

Parmi les programmes suivants, lequel permet de faire tracer à la tortue la figure ci-dessous ?

trois hexagones

Programme A :

def hexagone(tortue):
    for nb_cote in range(3) :
        tortue.forward(80)
        tortue.left(120)

t = Turtle()
for nb_poly in range(6) : 
    hexagone(t)
    t.left(60) 

Programme B :

def hexagone(tortue):
    for nb_cote in range(6) :
        tortue.forward(80)
        tortue.left(120)

t = Turtle()
for nb_poly in range(3) : 
    hexagone(t)
    t.left(60) 

Programme C :

def hexagone(tortue):
    for nb_cote in range(6) :
        tortue.forward(80)
        tortue.left(60)

t = Turtle()
for nb_poly in range(6) : 
    hexagone(tortue)
    t.left(120) 

Programme D :

def hexagone(tortue):
    for nb_cote in range(6) :
        tortue.forward(80)
        tortue.left(60)

t = Turtle()
for nb_poly in range(3) : 
    hexagone(t)
    t.left(120) 

  • A
  • B
  • C
  • D
  • A
  • B
  • C
  • D

Il y a 3 hexagones réguliers à tracer (range(3)). La fonction hexagone prend en paramètre une tortue et lui fait tracer 6 côtés (range(6)). Les angles internes de l'hexagone font 120° donc la tortue doit pivoter de 180 - 120 = 60°.
Lorsqu'on appelle cette fonction le paramètre prend pour valeur le nom de la tortue qui doit tracer le carré. Dans tous les programmes proposés, celle-ci s'appelle t.
Chaque hexagone est l'image d'un autre par une rotation d'un tiers d'angle plein (360/3 = 120°). Le sens de cette rotation importe peu : t.right(120) aurait aussi convenu.