290 lines
5.4 KiB
Markdown
290 lines
5.4 KiB
Markdown
# Fonctions utiles en Python
|
|
|
|
----
|
|
|
|
## Fonctions de types de données
|
|
|
|
----
|
|
|
|
### `int`
|
|
|
|
La fonction `int()` convertit une valeur en un entier. Si aucun argument n'est fourni, elle retourne 0.
|
|
|
|
```{.python .numberLines}
|
|
x = int(2.8) # x sera 2
|
|
y = int("3") # y sera 3
|
|
z = int() # z sera 0
|
|
w = int("6f", base=16) # w sera 111
|
|
v = int("10101", base=2) # v sera 21
|
|
```
|
|
|
|
----
|
|
|
|
### `str`
|
|
|
|
La fonction `str()` convertit une valeur en une chaîne. Si aucun argument n'est fourni, elle retourne une chaîne vide.
|
|
|
|
```{.python .numberLines}
|
|
x = str(2) # x sera "2"
|
|
y = str(3.8) # y sera "3.8"
|
|
z = str() # z sera ""
|
|
```
|
|
|
|
----
|
|
|
|
### `float`
|
|
|
|
La fonction `float()` convertit une valeur en un nombre à virgule flottante. Si aucun argument n'est fourni, elle retourne 0.0.
|
|
|
|
```{.python .numberLines}
|
|
x = float(2) # x sera 2.0
|
|
y = float("3.8") # y sera 3.8
|
|
z = float() # z sera 0.0
|
|
```
|
|
|
|
----
|
|
|
|
### `list`
|
|
|
|
La fonction `list()` est utilisée pour créer une liste.
|
|
|
|
```{.python .numberLines}
|
|
x = list((1, 2, 3)) # x sera [1, 2, 3]
|
|
y = list("oui") # y sera ["o", "u", "i"]
|
|
z = list() # z sera une nouvelle liste vide
|
|
```
|
|
|
|
----
|
|
|
|
### `dict`
|
|
|
|
La fonction `dict()` est utilisée pour créer un dictionnaire.
|
|
|
|
```{.python .numberLines}
|
|
x = dict(name="John", age=36) # x sera {'name': 'John', 'age': 36}
|
|
y = dict([("name", "John"), ("age", 36)]) # y sera {'name': 'John', 'age': 36}
|
|
z = dict() # z sera un nouveau dictionnaire vide
|
|
```
|
|
|
|
----
|
|
|
|
## Fonctions d'introspection
|
|
|
|
----
|
|
|
|
### `locals`
|
|
|
|
La fonction `locals()` renvoie un dictionnaire contenant les variables locales courantes.
|
|
|
|
```{.python .numberLines}
|
|
def ma_fonction():
|
|
x = 2
|
|
print(locals()) # Dictionnaire des variables disponibles au niveau de la fonction
|
|
|
|
ma_fonction() # Affiche {'x': 2}
|
|
```
|
|
|
|
----
|
|
|
|
### `getattr`
|
|
|
|
La fonction `getattr()` renvoie la valeur de l'attribut nommé d'un objet.
|
|
|
|
```{.python .numberLines}
|
|
class MaClasse:
|
|
x = 2
|
|
|
|
objet = MaClasse()
|
|
print(getattr(objet, "x")) # Affiche 2
|
|
print(getattr(objet, "y")) # Provoque une erreur
|
|
print(getattr(objet, "y", None)) # Affiche None si y est introuvable comme attribut de objet
|
|
```
|
|
|
|
----
|
|
|
|
### `type`
|
|
|
|
La fonction `type()` renvoie le type d'un objet.
|
|
|
|
```{.python .numberLines}
|
|
x = 2
|
|
print(type(x)) # Affiche <class 'int'>
|
|
```
|
|
|
|
----
|
|
|
|
### `isinstance`
|
|
|
|
La fonction `isinstance()` vérifie si un objet est une instance d'une classe spécifique.
|
|
|
|
```{.python .numberLines}
|
|
class MaClasse:
|
|
pass
|
|
|
|
objet = MaClasse()
|
|
print(isinstance(objet, MaClasse)) # Affiche True
|
|
```
|
|
|
|
----
|
|
|
|
### `dir`
|
|
|
|
La fonction `dir()` tente de renvoyer une liste d'attributs valides de l'objet.
|
|
|
|
```{.python .numberLines}
|
|
print(dir("Hello")) # Affiche une liste de méthodes et attributs de la classe str
|
|
```
|
|
|
|
----
|
|
|
|
## Fonctions utiles
|
|
|
|
----
|
|
|
|
### `print`
|
|
|
|
La fonction `print()` affiche les arguments à l'écran.
|
|
|
|
```{.python .numberLines}
|
|
print("Bonjour, monde !") # Affiche Bonjour, monde !
|
|
print("Je voudrais", 2, "baguettes.")
|
|
```
|
|
|
|
----
|
|
|
|
### `all`
|
|
|
|
La fonction `all()` renvoie `True` si **tous** les éléments d'un itérable sont vrais (ou équivalents, à savoir non
|
|
nuls ou non vides).
|
|
|
|
```{.python .numberLines}
|
|
liste = [True, True, True]
|
|
print(all(liste)) # Affiche True
|
|
```
|
|
|
|
----
|
|
|
|
### `any`
|
|
|
|
La fonction `any()` renvoie `True` si au moins un élément d'un itérable est vrai.
|
|
|
|
```{.python .numberLines}
|
|
liste = [False, True, False]
|
|
print(any(liste)) # Affiche True
|
|
```
|
|
|
|
----
|
|
|
|
### `ord`
|
|
|
|
La fonction `ord()` renvoie un entier représentant le code Unicode du caractère fourni.
|
|
|
|
```{.python .numberLines}
|
|
print(ord('A')) # Affiche 65
|
|
print(ord('a')) # Affiche 97
|
|
```
|
|
|
|
----
|
|
|
|
### `max`
|
|
|
|
La fonction `max()` renvoie le plus grand élément d'un itérable ou le plus grand de deux ou plusieurs arguments.
|
|
|
|
```{.python .numberLines}
|
|
print(max(1, 2, 3)) # Affiche 3
|
|
```
|
|
|
|
----
|
|
|
|
### `min`
|
|
|
|
La fonction `min()` renvoie le plus petit élément d'un itérable ou le plus petit de deux ou plusieurs arguments.
|
|
|
|
```{.python .numberLines}
|
|
print(min(1, 2, 3)) # Affiche 1
|
|
```
|
|
|
|
----
|
|
|
|
### `input`
|
|
|
|
La fonction `input()` lit une ligne à partir de l'entrée de la console, et renvoie le texte saisi, toujours sous forme
|
|
de chaîne de caractères.
|
|
|
|
```{.python .numberLines}
|
|
nom = input("Entrez votre nom : ")
|
|
print(nom)
|
|
```
|
|
|
|
----
|
|
|
|
### `round`
|
|
|
|
La fonction `round()` arrondit un nombre à un certain nombre de décimales.
|
|
|
|
```{.python .numberLines}
|
|
print(round(3.14159, 2)) # Affiche 3.14
|
|
```
|
|
|
|
----
|
|
|
|
### `enumerate`
|
|
|
|
La fonction `enumerate()` permet à chaque itération sur un objet, de renvoyer un tuple de taille 2,
|
|
contenant toujours un numéro séquentiel, suivi de l'élément parcouru à l'itération en cours.
|
|
|
|
```{.python .numberLines}
|
|
for i, v in enumerate(['a', 'b', 'c']):
|
|
print(i, v)
|
|
```
|
|
|
|
Affiche `0 a`, `1 b` puis `2 c`.
|
|
|
|
----
|
|
|
|
### `len`
|
|
|
|
La fonction `len()` renvoie le nombre d'éléments dans un objet.
|
|
|
|
```{.python .numberLines}
|
|
print(len("Bonjour")) # Affiche 7
|
|
```
|
|
|
|
----
|
|
|
|
### `range`
|
|
|
|
La fonction `range()` génère une séquence de nombres. La valeur de fin n'est jamais incluse dans l'intervalle.
|
|
|
|
```{.python .numberLines}
|
|
for i in range(5):
|
|
print(i) # Affiche les nombres de 0 à 4
|
|
```
|
|
|
|
```{.python .numberLines}
|
|
for i in range(5, 15):
|
|
print(i) # Affiche les nombres de 5 à 14
|
|
```
|
|
|
|
```{.python .numberLines}
|
|
for i in range(5, 15, 3):
|
|
print(i) # Affiche les nombres 5, 8, 11 et 14
|
|
```
|
|
|
|
----
|
|
|
|
### `zip`
|
|
|
|
La fonction `zip()` combine les éléments de
|
|
|
|
plusieurs itérables en tuples.
|
|
|
|
```{.python .numberLines}
|
|
nombres = [1, 2, 3]
|
|
lettres = ['a', 'b', 'c']
|
|
for n, l in zip(nombres, lettres):
|
|
print(n, l)
|
|
```
|
|
|
|
----
|