415 lines
5.3 KiB
Markdown
415 lines
5.3 KiB
Markdown
# Fonctions
|
|
|
|
|
|
|
|
#### Fonctions natives:
|
|
|
|
##### abs(x)
|
|
|
|
```python
|
|
# -retourne la valeur absolue
|
|
>>> abs(-3)
|
|
3
|
|
```
|
|
|
|
##### all(iterable)
|
|
|
|
```python
|
|
# -retourne True si tous les éléments d'un élément itérable sont True
|
|
>>> liste = [True, True, True, 1]
|
|
>>> all(liste)
|
|
True
|
|
```
|
|
|
|
##### any(iterable)
|
|
|
|
```python
|
|
# -retourne True si au moins un élément d'un élément itérable est True
|
|
>>> liste = [True, False, True, 1]
|
|
>>> any(liste)
|
|
True
|
|
|
|
```
|
|
|
|
##### bin(x)
|
|
|
|
```python
|
|
# -convertit un entier en chaine de caractères binaires
|
|
>>> bin(132)
|
|
'0b10000100'
|
|
|
|
```
|
|
|
|
##### bool()
|
|
|
|
```python
|
|
# -retourne la valeur boléenne
|
|
>>> bool(12)
|
|
True
|
|
>>> bool(0)
|
|
False
|
|
```
|
|
|
|
##### callable
|
|
|
|
```python
|
|
# -détermine si un objet est callable (exécutable ou appelable)
|
|
# -fonctions (user ou builtin), methodes
|
|
>>> callable("A")
|
|
False
|
|
>>> callable(int)
|
|
True
|
|
|
|
```
|
|
|
|
##### chr(n)
|
|
|
|
```python
|
|
# -retourne la caractère qui correspond à l'unicode n
|
|
>>> chr(97)
|
|
'a'
|
|
```
|
|
|
|
##### delattr()
|
|
|
|
```python
|
|
# -efface un attribut d'un objet
|
|
|
|
class Person:
|
|
name = "John"
|
|
age = 36
|
|
country = "Norway"
|
|
|
|
delattr(Person, 'age')
|
|
```
|
|
|
|
##### eval(expression)
|
|
|
|
```python
|
|
# -
|
|
>>> v =101
|
|
>>> eval('v+1')
|
|
102
|
|
|
|
```
|
|
|
|
##### format(val, format)
|
|
|
|
```python
|
|
# -formatte une valeur selon le format. spécifié
|
|
>>> x = format(5, 'b') # binaire
|
|
>>> x
|
|
'101'
|
|
>>> x = format(44, 'x') # hexa
|
|
>>> x
|
|
'2c'
|
|
```
|
|
|
|
##### getattr(objet, attribut)
|
|
|
|
```python
|
|
# -retourne la valeur de l'attribut de l'objet spécifié
|
|
class Person:
|
|
name = "John"
|
|
age = 36
|
|
country = "Norway"
|
|
|
|
x = getattr(Person, 'age')
|
|
36
|
|
```
|
|
|
|
##### hasattr(objet, attribut)
|
|
|
|
```python
|
|
# -retourne True si l'objet spécifié à l'attribut
|
|
class Person:
|
|
name = "John"
|
|
age = 36
|
|
country = "Norway"
|
|
|
|
x = hasattr(Person, 'age')
|
|
True
|
|
```
|
|
|
|
##### help(element)
|
|
|
|
```python
|
|
# -retourne l'aide sur l'élément
|
|
>>> help(tuple)
|
|
|
|
Help on class tuple in module builtins:
|
|
|
|
class tuple(object)
|
|
| tuple(iterable=(), /)
|
|
|
|
|
| Built-in immutable sequence.
|
|
|
|
|
|
```
|
|
|
|
##### hex()
|
|
|
|
```python
|
|
# -convertit un nombre en hexa`
|
|
>>> hex(15)
|
|
'0xf'
|
|
|
|
```
|
|
|
|
##### locals()
|
|
|
|
```python
|
|
# -retourne un dictionnaire avec des variables en cours
|
|
|
|
|
|
```
|
|
|
|
##### map(function)
|
|
|
|
```python
|
|
# -exécute une fonction sur chaque item d'un élément itérable
|
|
|
|
|
|
```
|
|
|
|
##### max() / min()
|
|
|
|
```python
|
|
# -retourne la valeur maxi ou mini
|
|
|
|
>>> min([1,3,6,99,125,-3])
|
|
-3
|
|
>>> max([1,3,6,99,125,-3])
|
|
125
|
|
|
|
```
|
|
|
|
##### next(iterable)
|
|
|
|
```python
|
|
# -retourne l'item suivant d'un itérable
|
|
>>> mylist = iter(["apple", "banana", "cherry"])
|
|
>>> x = next(mylist)
|
|
>>> x
|
|
'apple'
|
|
>>> x = next(mylist)
|
|
>>> x
|
|
'banana'
|
|
```
|
|
|
|
##### ord(caractère)
|
|
|
|
```python
|
|
# -retourne le code unicode du caractère
|
|
>>> x = ord("€")
|
|
>>> x
|
|
8364
|
|
```
|
|
|
|
##### pow(x, y, z)
|
|
|
|
```python
|
|
# -retourne x puissance y (modulo z)
|
|
>>> pow(2,4)
|
|
16
|
|
```
|
|
|
|
##### print(object(s) separator=separator, end=end, file=file, flush=flush)
|
|
|
|
```python
|
|
# -affiche le message à l'écran ou sur une autre sortie
|
|
# -par défaut, end='\'
|
|
>>> print("Hello", "how are you?", sep=" --- ")
|
|
Hello --- how are you?
|
|
|
|
fichier = open("test.py","r")
|
|
print(fichier.read())
|
|
fichier.close()
|
|
```
|
|
|
|
##### randint()
|
|
|
|
```python
|
|
# -retourne un entier aléatoire
|
|
|
|
>>> import random
|
|
>>> random.randint(1,100)
|
|
76
|
|
|
|
```
|
|
|
|
##### random()
|
|
|
|
```python
|
|
# -retourne une valeur aléatoire
|
|
|
|
>>> import random
|
|
>>> random.random()
|
|
0.893485376651602
|
|
|
|
```
|
|
|
|
##### range(x)
|
|
|
|
```python
|
|
# -crée une séquence de nombre de 0 à x (exclu)
|
|
x = range(4) # de 0 à 3
|
|
for n in x:
|
|
print(n)
|
|
0
|
|
1
|
|
2
|
|
3
|
|
|
|
x = range(3, 6) # de 3 à 5
|
|
for n in x:
|
|
print(n)
|
|
3
|
|
4
|
|
5
|
|
|
|
x = range(0,6,2) # de 0 à 5 et un pas de 2
|
|
for n in x:
|
|
print(n)
|
|
0
|
|
2
|
|
4
|
|
```
|
|
|
|
|
|
|
|
##### reverse()
|
|
|
|
```python
|
|
# -inverse l'ordre d'une liste
|
|
|
|
>>> x = [1,2,3]
|
|
>>> x.reverse()
|
|
>>> x
|
|
[3, 2, 1]
|
|
|
|
```
|
|
|
|
##### reversed()
|
|
|
|
```python
|
|
# -retourne un itérateur inversé
|
|
|
|
>>> list(reversed([1,2,3,4]))
|
|
[4, 3, 2, 1]
|
|
|
|
```
|
|
|
|
##### round(number)
|
|
|
|
```python
|
|
# -retourne l'arrondi d'un nombre
|
|
|
|
>>> round(-1.2)
|
|
-1
|
|
>>> round(-1.2563679)
|
|
-1
|
|
|
|
```
|
|
|
|
##### set(iterable)
|
|
|
|
```python
|
|
# -crée un objet set
|
|
# -un set est une collection non ordonnée et non indexé
|
|
|
|
x = set(('apple', 'banana', 'cherry'))
|
|
>>> x
|
|
{'apple', 'cherry', 'banana'}
|
|
```
|
|
|
|
##### slice(start, end, step)
|
|
|
|
```python
|
|
# -retourne un objet slice
|
|
>>> a = ("a", "b", "c", "d", "e", "f", "g", "h")
|
|
|
|
>>> x = slice(2)
|
|
>>> print(a[x])
|
|
('a', 'b')
|
|
|
|
>>> x = slice(3, 5)
|
|
>>> print(a[x])
|
|
('d', 'e')
|
|
|
|
>>> x = slice(0, 8, 3)
|
|
>>> print(a[x])
|
|
('a', 'd', 'g')
|
|
|
|
```
|
|
|
|
|
|
|
|
##### shuffle()
|
|
|
|
```python
|
|
# -mélange aléatoirement une liste
|
|
|
|
>>> import random
|
|
>>> x = [1,2,3,4,5]
|
|
>>> random.shuffle(x)
|
|
>>> x
|
|
[2, 5, 4, 1, 3]
|
|
|
|
```
|
|
|
|
##### list.sort()
|
|
|
|
```python
|
|
# -permet de trier une liste
|
|
|
|
>>> l = [67,34,89,12,70,345,2,-56]
|
|
>>> l.sort()
|
|
>>> l
|
|
[-56, 2, 12, 34, 67, 70, 89, 345]
|
|
|
|
```
|
|
|
|
##### sorted(iterable)
|
|
|
|
```python
|
|
# -tri un élément itérable
|
|
|
|
>>> sorted([3,2,12,1])
|
|
[1, 2, 3, 12]
|
|
|
|
```
|
|
|
|
##### sum(iterable)
|
|
|
|
```python
|
|
# -retourne la somme des valeurs d'un élément itérable
|
|
|
|
>>> sum([12,24,36])
|
|
72
|
|
```
|
|
|
|
##### upper()
|
|
|
|
```python
|
|
# -met en majuscule la chaine de caractères
|
|
|
|
>>> "Python".upper()
|
|
'PYTHON'
|
|
```
|
|
|
|
##### zip(*iterables)
|
|
|
|
```python
|
|
# -permet de regrouper sous la forme d'un tuple les items de listes.
|
|
# - https://stackoverflow.com/questions/31683959/the-zip-function-in-python-3
|
|
|
|
>>> a = ["sharon", "sophie", "halle"]
|
|
>>> b = ["stone", "marceau", "berry"]
|
|
>>> zip(a,b)
|
|
<zip object at 0x10e1009c8>
|
|
>>> list(zip(a,b))
|
|
[('sharon', 'stone'), ('sophie', 'marceau'), ('halle', 'berry')]
|
|
```
|
|
|