# Création et appels des fonctions

## Définition d’une fonction

Une fonction est un bloc d’instructions dont le but est de faire une tâche spécifique du programme.

## Quel est le but des fonctions

Le but dans la création de fonctions est de découper le programme en plusieurs parties (modularisation) afin de les réutiliser à plusieurs endroits du programme et améliorer l’organisation et la lisibilité du code.

## Les fonctions natives (ou intrinsèques)

Les fonctions intrinsèques sont des fonctions prédéfinies de Python (*Build-in functions*) que le programmeur peut utiliser.

Exemples de fonction (vous utilisez déjà quelques unes) :

* `print(chaîne)` : affiche la chaîne de caractères passé en paramètre.
* `len(liste)` : retourne la longueur d’une liste.
* `type(x)` : retourne le type de la variable x.
* `int(x)`, `float(x)`, `str(x)`: retournent respectivement les valeurs converties en entier, réel et chaîne de caractère.
* `range(n)` : retourne une séquence de nombres selon ce qu’on lui passe en paramètres.

Vous trouverez plus de fonctions natives dans la documentation officielle de Python suivante : &#x20;

{% embed url="<https://docs.python.org/fr/3/library/functions.html>" %}

## Syntaxe

### Déclaration d'une fonction

```python
def nom_fonction(parametre_1, parametre_2, ..., parametre_n):
    instruction_1
    instruction_2
    ...
    instruction_n
    return resultat # Résultat étant la valeur de retour de la fonction
```

* *`def`* : c'est un mot clé pour définir une fonction en Python.
* *`nom_fonction`* :c'est le nom de la fonction. Celui ci doit être significatif et soigneusement choisi (tout comme le nom d'une variable).
* *`parametre_1, parametre_2, ..., parametre_n`* (optionnel): ce sont les paramètres de la fonction. On les utilise pour passer des valeurs à la fonction *`nom_fonction`*. Un paramètre doit être utilisé dans le corp de la fonction et il prend la valeur qu’on lui passe lorsqu’on appelle la fonction. <mark style="background-color:green;">En dehors de cette fonction, le paramètre n’existe pas dans le reste du code</mark>.
* *`instruction_1, instruction_1, ..., instruction_1`* : ce sont des lignes de code formant le corp de la fonction.
* *`return resultat`* (optionnel): *`return`* est un mot clé qui permet de retourner une valeur (*`resultat`*) calculée dans la fonction. *`resultat`* est appelée valeur de retour.

{% hint style="danger" %}
Ne pas oublier&#x20;

* les deux points `:`.
* l’indentation dans le corp de la fonction.

Ils font partie de la syntaxe de la fonction.
{% endhint %}

{% hint style="danger" %}
Une fonction est exécutée uniquement lorsqu'elle [est appelée](#appel-dune-fonction).
{% endhint %}

### Appel d'une fonction

Pour appeler une fonction, on doit écrire le nom de la fonction en lui passant les paramètres dont elle a besoin. La fonction doit évidemment être définie avant.

{% hint style="info" %}
Il est possible d’appeler une fonction&#x20;

* dans le programme principal.
* dans une autre fonction.
  {% endhint %}

## &#x20;Exemples

#### Exemple 1 : fonction sans paramètres et sans valeur de retour

{% code title="Déclaration de la fonctio print\_hello\_worldn " %}

```python
def print_hello_world():
    print("**** Hello World ****")
```

{% endcode %}

{% code title="Appel de la fonction print\_hello\_world" %}

```python
print_hello_world()
```

{% endcode %}

#### Exemple 2 : fonction avec paramètres et sans valeur de retour

<pre class="language-python" data-title="Déclaration de la fonction affichage"><code class="lang-python">def affichage(chaine1, chaine2):
<strong>    print("*"*50)
</strong>    concatenation = chaine1 + " " + chaine2
    print(concatenation)
    print("*"*50)
</code></pre>

{% code title="Appel de la fonction affichage" %}

```python
affichage("chaine de caractères 1", "chaine de caractères 2")
```

{% endcode %}

#### Exemple 3 : fonction avec paramètres et avec valeur de retour

{% code title="Déclaration de la fonction addition" %}

```python
def addition(x, y, z):
    somme = x + y + z
    return somme
```

{% endcode %}

{% code title="Appel de la fonction addition" %}

```python
addition(15,30,7)
```

{% endcode %}

## Programme principal

`if __name__ == "__main__":` vient après la déclaration des fonctions et marque le début du programme principal.

{% hint style="info" %}
**Définition simplifiée** :&#x20;

`if __name__ == "__main__":` s'assure que le programme en cours d'exécution est le programme principal afin que son contenu (sous le`if __name__ == "__main__":`) soit exécuté.\\

**Définition un peu moins évidente pour vous :**&#x20;

`if __name__ == "__main__":` est utilisé pour déterminer si un programme Python (dans un fichier .py) est exécuté en tant que programme principal ou s'il est importé en tant que module dans un autre programme. Si celui est importé, le programme principal (sous le`if __name__ == "__main__":`) n'est pas exécuté.
{% endhint %}

#### Exemple :&#x20;

```python
def addition(x, y, z):
    somme = x + y + z
    return somme

if __name__ == "__main__" :
    addition(15,30,7)
```

## Paramètres par défaut

Il est possible de définir des valeurs par défaut pour les paramètres d'une fonction. Les valeurs par défaut sont utilisées lorsque la fonction est appelée sans fournir une valeur explicite pour un paramètre.

### Syntaxe

{% code fullWidth="false" %}

```python
def nom_fonction(parametre_1, parametre_2 = valeur_par_defaut2, parametre_3 = valeur_par_defaut3, ...):
    # Corp de la fonction
   
```

{% endcode %}

{% hint style="danger" %}
Assurez-vous de placer les paramètres avec des valeurs par défaut à la fin de la liste des paramètres de la fonction.
{% endhint %}

### Exemple

<pre class="language-python"><code class="lang-python">def addition(x, y = 5, z = 3)
    somme = x + y + z
    return somme

if __name__ == "__main__" :
    somme1 = addition(2)
    somme2 = addition(2, 0)
    somme3 = addition(2, 0, 6)
    somme4 = addition(x=9, y=6, z=0)
    somme5 = addition(z=0, x=9, y=6)
    
<strong>    print(somme1)
</strong>    print(somme2)
    print(somme3)
    print(somme4)
    print(somme5)
</code></pre>

{% content-ref url="../activites-avec-legos/consolidation-sur-les-fonctions-avec-des-blocs" %}
[consolidation-sur-les-fonctions-avec-des-blocs](https://cours-5.gitbook.io/dalicia-420-1g2-hu-logique-de-programmation/activites-avec-legos/consolidation-sur-les-fonctions-avec-des-blocs)
{% endcontent-ref %}
