miroir de
https://github.com/PAPAMICA/Wiki-Tech.io.git
synchronisé 2025-01-09 16:40:47 +01:00
223 lignes
Pas d'EOL
6,4 Kio
Markdown
223 lignes
Pas d'EOL
6,4 Kio
Markdown
---
|
||
title: Python - Fonctions avancées
|
||
description:
|
||
published: true
|
||
date: 2022-01-26T15:50:50.684Z
|
||
tags:
|
||
editor: markdown
|
||
dateCreated: 2021-05-24T16:13:51.003Z
|
||
---
|
||
|
||
|
||
|
||
# Fonction basique
|
||
Une fonction (ou méthode), est un bloc d'instructions réutilisable. Si vous venez à réécrire plusieurs fois les mêmes lignes dans votre code, cela signifie que vous pouvez les mettre sous forme de fonction. Votre code sera alors beaucoup plus lisible.
|
||
|
||
## Déclarer une fonction
|
||
Une fonction se déclare avec le mot-clé "def" et nécessite une identation.
|
||
Il suffira ensuite d'appeler la fonction par son nom.
|
||
```python
|
||
#Déclaration de la fonction
|
||
def print_something_useless():
|
||
print("Il fait beau aujourd'hui")
|
||
|
||
#Appel de la fonction
|
||
print_something_useless()
|
||
|
||
>>> Il fait beau aujourd'hui
|
||
```
|
||
|
||
## Les arguments
|
||
Une fonction peut demander des arguments. Ce sont des variables à renseigner lors de l'appel de la fonction permettant son execution.
|
||
```python
|
||
def divide_numbers(dividende,diviseur):
|
||
quotient = dividende/diviseur
|
||
print(quotient)
|
||
|
||
divide_numbers(4,2)
|
||
|
||
>>> 2
|
||
```
|
||
|
||
Il est possible d'attribuer une valeur par défaut à un argument. Celle-ci sera remplacée si on précise une valeur.
|
||
|
||
```python
|
||
def divide_numbers(dividende,diviseur=3):
|
||
quotient = dividende/diviseur
|
||
print(quotient)
|
||
|
||
divide_numbers(9) #cas 1 : valeur par défaut
|
||
divide_numbers(9,9) #cas 2 : nouvelle valeur
|
||
|
||
>>> 3 #cas 1
|
||
>>> 1 #cas 2
|
||
```
|
||
|
||
### Récupérer le résultat d'une fonction
|
||
Il est important de noter que toutes les variables d'une focntion sont locales. Une fois l'éxecution de la fonction terminée, toutes ses variables sont effacées. Dans l'exemple précédent il aurait pu être intéressant de récupérer le résultat de la division pour la suite de notre script.
|
||
Pour ce faire on utilise le mot-clé ***return***.
|
||
Ensuite, on attribue l'appel de la fonction à une ou plusieurs variables.
|
||
> Il est possible de retourner plusieurs valeurs
|
||
{.is-info}
|
||
|
||
```python
|
||
def operations(nb1,nb2):
|
||
quotient = nb1/nb2
|
||
produit = nb1*nb2
|
||
somme = nb1 + nb2
|
||
|
||
return quotient,produit,somme
|
||
|
||
div, mult, add = operations(4,2)
|
||
print("division : " + div)
|
||
print("multiplication : " + mult)
|
||
print("addition : " + add)
|
||
|
||
>>> division : 2
|
||
>>> multiplication : 8
|
||
>>> addition : 6
|
||
```
|
||
|
||
## Fonction "main"
|
||
La fonction ***main*** est la fonction principale du script. Elle définit le point d'entrée du script et appelle les autres fonctions. C'est la fonction ***main*** qui va définir le déroulement du script.
|
||
Cette fonction spéciale est appelée grâce à un ***if***, qui sera le seul bloc d'instruction hors fonction.
|
||
> La fonction *main* ne demande pas d'arguments.
|
||
{.is-info}
|
||
|
||
|
||
```python
|
||
def print_something_useless():
|
||
print("Il fait beau aujourd'hui")
|
||
|
||
def operations(nb1,nb2):
|
||
quotient = nb1/nb2
|
||
produit = nb1*nb2
|
||
somme = nb1 + nb2
|
||
|
||
return quotient,produit,somme
|
||
|
||
def main():
|
||
print("Je suis le main")
|
||
print_something_useless()
|
||
div, mult, add = operations(4,2)
|
||
print("division : " + div)
|
||
print("multiplication : " + mult)
|
||
print("addition : " + add)
|
||
print_something_useless()
|
||
|
||
if __name__ == '__main__':
|
||
main()
|
||
|
||
>>> Je suis le main
|
||
>>> Il fait beau aujourd'hui
|
||
>>> division : 2
|
||
>>> multiplication : 8
|
||
>>> addition : 6
|
||
>>> Il fait beau aujourd'hui
|
||
```
|
||
|
||
# Fonction de classe
|
||
|
||
# Le constructeur
|
||
|
||
Un constructeur est une méthode spéciale d'une classe qui permet de construire un objet, de lui donner des attributs.
|
||
|
||
Le nom de cette méthode est “ \_\_init\_\_ ” et prend en premier argument “ self ”, qui représente l'objet courant, qui est cours de création.
|
||
|
||
*Exemple : je crée un constructeur permettant de définir une personne*
|
||
|
||
```python
|
||
class People:
|
||
def __init__(self,firstname,lastname,age):
|
||
self.firstname = firstname
|
||
self.lastname = lastname
|
||
self.age = age
|
||
```
|
||
|
||
Notre fonction init demande 3 paramètres, “ self ” étant un paramètre spécial.
|
||
|
||
Grâce à ce constructeur il ne reste qu'à créer des objets :
|
||
|
||
```python
|
||
>>> chuck = People("Chuck","Norris",81)
|
||
```
|
||
|
||
L'objet “chuck” a été créé, on peut désormais accéder à ses différents attributs, les lire et les modifier.
|
||
|
||
```python
|
||
>>> chuck.firstname
|
||
'Chuck'
|
||
>>> chuck.firstname = "Chucky"
|
||
>>> chuck.firstname
|
||
'Chucky'
|
||
```
|
||
|
||
# Le représentateur
|
||
|
||
Reprenons l'exemple précédent. Lorsque l'on souhaite afficher notre objet, la valeur retournée n'est pas tout à fait celle attendue.
|
||
|
||
```python
|
||
>>> chuck
|
||
<__main__.People object at 0x03C12820>
|
||
```
|
||
|
||
Nous allons donc utiliser un représentateur pour mettre en forme l'objet.
|
||
|
||
Cette méthode se définit “ \_\_repr\_\_ ”.
|
||
|
||
```python
|
||
class People:
|
||
def __init__(self,firstname,lastname,age):
|
||
self.firstname = firstname
|
||
self.lastname = lastname
|
||
self.age = age
|
||
|
||
def __repr__(self):
|
||
return "Nom : %s , Prenom : %s , Age : %s" % (self.lastname, self.firstname, self.age)
|
||
```
|
||
|
||
```python
|
||
>>> repr(chuck)
|
||
'Nom : Norris , Prenom : Chuck , Age : 81'
|
||
```
|
||
|
||
# Le décorateur
|
||
|
||
Le décorateur est une fonction permettant de modifier le comportement d'autres fonctions, évitant la répétition de code. Il est appelé par “ @nom\_décoraeur ”.
|
||
|
||
```python
|
||
def title_decorator(function):
|
||
def wrapper(*args, **kwargs):
|
||
print("*"*30)
|
||
print("-"*30)
|
||
function(*args, **kwargs)
|
||
print("-"*30)
|
||
print("*"*30)
|
||
return wrapper
|
||
|
||
@title_decorator
|
||
def title(titre):
|
||
print(titre)
|
||
|
||
>>> titre = "Ceci est mon texte décoré"
|
||
>>> title(titre)
|
||
******************************
|
||
------------------------------
|
||
Ceci est mon texte décoré
|
||
------------------------------
|
||
******************************
|
||
```
|
||
|
||
Ce décorateur permet simplement de mettre en forme un titre. Mais le décorateur, critiqué pour son nom ne définissant pas assez clairement sa fonction, peut avoir bien d'autres usages.
|
||
|
||
Par exemple, dans le cadre du _développement web_, les décorateurs sont très utilisés. Typiquement, pour les pages nécessitant une authentification, le décorateur “ @login\_required ” du framework Django est très utile.
|
||
|
||
```python
|
||
from django.contrib.auth.decorators import login_required
|
||
|
||
@login_required
|
||
def my_page(request):
|
||
...
|
||
```
|
||
|
||
Tout comme “ @login\_required ”, beaucoup de décorateurs sont déjà développés, nécessitant un simple import. |