help(round)

## Que se passe-t-il si ndigits = -1 pour number = 13.135 ?
round(13.135,-1)

help(round(-2.01))

help(print)

def least_difference(a, b, c):
    diff1 = abs(a - b)
    diff2 = abs(b - c)
    diff3 = abs(a - c)
    return min(diff1, diff2, diff3)

## Un essai à la fois
print(least_difference(1, 10, 100))

## Trois essais d'un coup !
print(
    least_difference(1, 10, 100),
    least_difference(1, 10, 10),
    least_difference(5, 6, 7), # Python autorise les virgules de fin dans les listes d'arguments. N'est-ce pas sympa (How nice is that?) ?
)

def least_difference(a, b, c):
    """Renvoie la plus petite différence entre deux nombres
parmi a, b et c.
    
    >>> least_difference(1, 5, -5)
    4
    """
    diff1 = abs(a - b)
    diff2 = abs(b - c)
    diff3 = abs(a - c)
    return min(diff1, diff2, diff3)

help(least_difference)

def least_difference(a, b, c):
    """Return the smallest difference between any two numbers
    among a, b and c.
    """
    diff1 = abs(a - b)
    diff2 = abs(b - c)
    diff3 = abs(a - c)
    min(diff1, diff2, diff3)
    
print(
    least_difference(1, 10, 100),
    least_difference(1, 10, 10),
    least_difference(5, 6, 7),
)

mystery = print()
print(mystery)

print(1, 2, 3, sep=' < ')

print(1, 2, 3)

def greet(who="Colin"):
    print("Hello,", who)
    
greet()
greet(who="Kaggle")
# (Dans ce cas, nous n’avons pas besoin de spécifier le nom de l’argument, car il est sans ambiguïté.)
greet("world")

## Pourquoi cette fonction :
def greet(who="Colin"):
    print("Hello,", who)
greet()
## n'a pas besoin de return ?

## La fonction d'origine

def mult_by_five(x):
    return 5 * x

def call(fn, arg):
    """Appeler fn sur arg"""
    return fn(arg)

def squared_call(fn, arg):
    """Appeler fn sur le résultat de l'appel de fn sur arg"""
    return fn(fn(arg))

print(
    call(mult_by_five, 1),
    squared_call(mult_by_five, 1), 
    sep='\n', # '\n' est le caractère de nouvelle ligne - il démarre une nouvelle ligne
)

## La fonction documentée

def mult_by_five(x):
    """
    Multiplie le nombre donné par 5.

    Args:
        x (int ou float): Le nombre à multiplier.

    Returns:
        int ou float: Le résultat de la multiplication de x par 5.
    """
    return 5 * x

def call(fn, arg):
    """
    Appelle la fonction donnée avec l'argument spécifié.

    Args:
        fn (fonction): La fonction à appeler.
        arg: L'argument à passer à la fonction.

    Returns:
        Le résultat de l'appel de fn avec arg.
    """
    return fn(arg)

def squared_call(fn, arg):
    """
    Appelle la fonction donnée deux fois, en utilisant le résultat du premier appel comme argument pour le second.

    Args:
        fn (fonction): La fonction à appeler.
        arg: L'argument initial à passer à la fonction.

    Returns:
        Le résultat de l'appel de fn(fn(arg)).
    """
    return fn(fn(arg))

# Appel des fonctions et affichage des résultats
print(
    call(mult_by_five, 1),  # Appelle mult_by_five(1), ce qui donne 5
    squared_call(mult_by_five, 1),  # Appelle mult_by_five(mult_by_five(1)), ce qui donne 25
    sep='\n',  # Utilise un saut de ligne comme séparateur entre les résultats
)

## La fonction d'origine

def mod_5(x): # mod est un reccourci pour modulo
    """Renvoie le reste de x après avoir divisé par 5"""
    return x % 5

print(
    'Quel nombre est le plus grand ?',
    max(100, 51, 14),
    'Quel nombre est le plus grand modulo 5 ?',
    max(100, 51, 14, key=mod_5),
    sep='\n',
)

## La fonction documentée

def mod_5(x):
    """
    Renvoie le reste de x après avoir divisé par 5.

    Args:
        x (int): Le nombre à diviser par 5.

    Returns:
        int: Le reste de la division de x par 5 (0, 1, 2, 3, ou 4).
    """
    return x % 5

print(
    'Quel nombre est le plus grand ?',
    max(100, 51, 14),
    'Quel nombre est le plus grand modulo 5 ?',
    max(100, 51, 14, key=mod_5),
    sep='\n',
)

## Comment afficher tous les chiffres pairs entre 0 et 10

def print_modulo(): 
    """ Affiche tous les chiffres pairs compris entre 0 et 10 """
    for i in range(10): 
        if i % 2 == 0: 
            print(i) 

print_modulo()

## Impression de la documentation (docstring)
print(print_modulo.__doc__)

## Comment afficher tous les chiffres impairs entre 0 et 10

def print_modulo(): 
    """ Affiche tous les chiffres impairs compris entre 0 et 10 """
    for i in range(10): 
        if i % 2 != 0: 
            print(i) 

print_modulo()

fiche mémo : 2.2. Fonctions et obtention de l'aide.¶

Appel de fonctions, définition de nos propres fonctions, et utilisation de la documentation intégrée de Python¶

Vincent GODARD - V1 - 25/02/2025¶

Cours Introduction à la programmation¶

Département de géographie - L3 - Université de Paris 8¶

1. Obtenir de l'aide¶¶

2. Définition des fonctions¶¶

3. Docstrings¶

3. Les fonctions qui ne renvoient pas de données¶

4. Arguments par défaut¶¶

5. Fonctions appliquées aux fonctions¶¶

5.1. 1er exemple de fonctions appliquées aux fonctions¶

5.2. 2ème exemple de fonctions appliquées aux fonctions¶

5.3. 3ème exemple de fonctions appliquées aux fonctions¶