Python est livré avec de nombreuses fonctions intégrées que vous pouvez utiliser sans importer de bibliothèque. Il y en a 64. Dans cet article, vous aurez un aperçu des plus importants.
- Pour une liste complète des fonctions intégrées de Python, consultez cette ressource.
- Pour un tutoriel vidéo complet cours sur les fonctions intégrées de Python, consultez ce cours Finxter Computer Science Academy.
Plongeons-nous ensuite dans les 29 fonctions intégrées Python les plus importantes !
help()
help() intégré de Python La fonction lance le système d'aide de Python. Sans argument, help() démarre une session interactive. Avec un argument de chaîne, help(name) recherche le nom et affiche une page d'aide sur le shell. Avec un argument non-chaîne, help(object) imprime une page d'aide sur l'objet.
>>> help(list) # Prints the documentation of list
>>> help(dict) # Prints the documentation of dict
>>> help(int) # Prints the documentation of int
>>> help('help') # Prints the documentation of help()
>>> help() # Opens an interactive "help" session
input()
input() intégré de Python La fonction lit une chaîne à partir de l'entrée standard. La fonction se bloque jusqu'à ce que cette entrée soit disponible et que l'utilisateur appuie sur ENTER. Vous pouvez ajouter un prompt facultatif string comme argument pour imprimer une chaîne personnalisée sur la sortie standard sans caractère de fin de ligne pour indiquer à l'utilisateur que votre programme attend son entrée.
>>> s = input() 42 >>> s '42'
print()
print() intégré de Python La fonction imprime une représentation sous forme de chaîne de n'importe quel nombre d'objets sur la sortie standard. Le print() La fonction a de nombreux arguments avancés pour personnaliser le comportement, tels que l'argument séparateur pour définir une chaîne de séparation personnalisée entre les objets imprimés, l'argument end pour définir une chaîne de fin personnalisée ou l'argument file qui vous permet même d'imprimer une chaîne dans un objet fichier.
>>> print('hello')
hello
>>> print('hello world')
hello world
>>> print(42)
42
>>> print(1, 2, 3)
1 2 3
>>> print('hello', 'world', sep = '\n')
hello
world
>>> print('hello', 'world', sep = '\n', end = '\n-----\n')
hello
world
-----
format()
format(value, spec) intégré de Python La fonction transforme l'entrée d'un format en sortie d'un autre format défini par vous. Plus précisément, il applique le spécificateur de format spec à l'argument value et renvoie une représentation formatée de value . Par exemple, format(42, 'f') renvoie la représentation sous forme de chaîne '42.000000' .
>>> format(42) '42' >>> format(42, 'f') '42.000000' >>> format(42, '.10f') '42.0000000000' >>> format(42, '.2f') '42.00'
exec()
exec() de Python La fonction exécute le code Python que vous transmettez en tant qu'argument de chaîne ou d'objet exécutable. C'est ce qu'on appelle l'exécution dynamique car, contrairement à la norme statique Code Python, vous pouvez générer du code et l'exécuter lors de l'exécution. De cette façon, vous pouvez exécuter du code Python créé par programme.
>>> program = 'print("hello world")'
>>> exec(program)
hello world
>>> exec('x=2; y=4; print(x+y)')
6 Chaque maître Python comprend très bien les bases. Les fonctions intégrées de Python sont la base même de toute votre carrière de codage. Pour un cours complet sur les 64 fonctions intégrées de Python, consultez la Finxter Computer Science Academy :
eval()
Python eval(s) analyse l'argument de chaîne s dans une expression Python, l'exécute et renvoie le résultat de l'expression. Cela pose un risque de sécurité car un utilisateur peut l'utiliser pour exécuter du code sur votre ordinateur. Par exemple, si vous autorisez eval(input()) , un utilisateur pourrait taper os.system('rm -R *') pour supprimer tous les fichiers de votre répertoire personnel.
>>> eval('2+2')
4
>>> eval('[1, 2, 3]*3')
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> eval('[x for x in range(10)]')
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> eval('"Alice".replace("e", "")')
'Alic'
compile()
compile() intégré de Python La méthode renvoie un objet de code exécutable sous la forme d'un "arbre de syntaxe abstraite" représenté par un ast objet. En passant cet objet code dans le exec() ou eval() fonctions, vous pouvez l'exécuter dynamiquement dans votre code Python. De cette façon, vous pouvez créer par programmation du code source et l'exécuter au moment de l'exécution. Pour utiliser la fonction, passez le code de la chaîne à exécuter, le nom du fichier et le mode d'exécution. Par exemple compile('print("hi")', '<string>', 'exec') crée un objet de code composé d'une ligne print("hi") .
# 1. Read code from file
f = open('filename.py', 'r')
code = f.read()
f.close()
# 2. Compile code string
code_obj = compile(code, 'filename.py', 'exec')
# 3. Run the code object (ast)
exec(code_obj)
abs()
abs(x) intégré de Python la fonction renvoie la valeur absolue de l'argument x qui peut être un entier, un flottant ou un objet implémentant le __abs__() fonction. Pour un nombre complexe, la fonction renvoie sa grandeur. La valeur absolue de tout argument d'entrée numérique -x ou +x est la valeur positive correspondante +x .
# POSITIVE INTEGER x = 42 print(abs(x)) # NEGATIVE INTEGER x = -42 print(abs(x)) # POSITIVE FLOAT x = 42.42 print(abs(x)) # NEGATIVE FLOAT x = -42.42 print(abs(x))
divmod()
divmod(a, b) intégré de Python la fonction prend deux nombres entiers ou flottants a et b comme arguments d'entrée et renvoie un tuple (a // b, a % b) . La première valeur de tuple est le résultat de la division entière a//b . Le deuxième tuple est le résultat du reste, également appelé opération modulo a % b . En cas d'entrées flottantes, divmod() renvoie toujours la division sans reste en arrondissant au nombre de tours inférieur.
# divmod() with integers >>> divmod(10, 2) (5, 0) >>> divmod(10, 3) (3, 1) >>> divmod(10, 4) (2, 2) >>> divmod(10, 5) (2, 0) >>> divmod(10, 10) (1, 0)
round()
round() intégré de Python la fonction prend deux arguments d'entrée :un number et un precision facultatif en chiffres décimaux. Il arrondit le nombre à la précision donnée et renvoie le résultat. La valeur de retour a le même type que le nombre d'entrée—ou un entier si le precision argument est omis. Par défaut, la précision est définie sur 0 chiffre, donc round(3.14) résultats en 3 .
>>> round(3.14) 3 >>> round(3.14, ndigits=1) 3.1 >>> round(3.13, ndigits=-1) 0.0 >>> round(4458.1242, ndigits=-1) 4460.0 >>> round(3.14159, ndigits=3) 3.142
hash()
hash(object) intégré de Python La fonction prend un objet comme argument et renvoie sa valeur de hachage. Comme la valeur de hachage est calculée sur la base des données de l'objet, deux objets différents mais égaux doivent avoir la même valeur de hachage. Il ne s'ensuit pas, cependant, que deux objets avec la même valeur de hachage sont égaux :ils peuvent avoir la même valeur de hachage et être toujours différents.
>>> hash(42)
42
>>> hash('42')
-7286207279771019371
callable()
callable(object) intégré de Python renvoie True si vous pouviez appeler le object argument comme une fonction avec les parenthèses finales dans object() . Vous pouvez rendre n'importe quel objet appelable en implémentant le __call__() de l'instance méthode. Par exemple, callable(callable) renvoie True car callable est un objet fonction. Mais callable(3) renvoie False car un entier n'est pas une fonction que vous pouvez appeler.
>>> callable(callable) True >>> callable(3) False
iter()
iter() intégré de Python La fonction renvoie un itérateur pour l'objet donné. Par exemple, iter([1, 2, 3]) crée un itérateur pour la liste [1, 2, 3] . Vous pouvez ensuite itérer sur tous les éléments de l'itérateur, un élément à la fois, dans une boucle for ou while telle que :for x in iter([1, 2, 3]) .
customers = ['Alice', 'Bob', 'Carl', 'Dave', 'Elena', 'Frank']
iterator = iter(customers)
print(next(iterator))
print(next(iterator))
for x in iterator:
print(x)
''' OUT:
Alice
Bob
Carl
Dave
Elena
Frank
''' Chaque maître Python comprend très bien les bases. Les fonctions intégrées de Python sont la base même de toute votre carrière de codage. Pour un cours complet sur les 64 fonctions intégrées de Python, consultez la Finxter Computer Science Academy :
next()
Le next(iterator) La fonction est l'une des fonctions intégrées de Python. Vous pouvez donc l'utiliser sans importer de bibliothèque. Il renvoie la valeur suivante à partir du iterator vous passez comme premier argument obligatoire. Un deuxième argument facultatif default renvoie la valeur par défaut passée au cas où l'itérateur ne fournirait pas de valeur suivante.
users = ['Alice', 'Bob', 'Carl', 'David'] # convert the list to an iterator users_iterator = iter(users) x = next(users_iterator) print(x) # Output: 'Alice' x = next(users_iterator) print(x) # Output: 'Bob' x = next(users_iterator) print(x) # Output: 'Carl' x = next(users_iterator) print(x) # Output: 'David'
list()
Le Python range() La fonction crée un itérable d'entiers suivants dans une plage de valeurs donnée. Vous pouvez passer soit seulement un stop argument auquel cas le range l'objet inclura tous les entiers de 0 à stop (exclu). Ou vous pouvez passer start , stop , et step arguments auquel cas l'objet range ira de start à step en utilisant le step donné Taille. Par exemple, range(3) résultats en 0, 1, 2 et range(2, 7, 2) résultats en 2, 4, 6 .
>>> x = [1, 2, 3] >>> y = list(x) >>> x is y False >>> x == y True
range()
Le Python range() La fonction crée un itérable d'entiers suivants dans une plage de valeurs donnée. Vous pouvez passer soit seulement un stop argument auquel cas le range l'objet inclura tous les entiers à partir de 0 à stop (exclu). Ou vous pouvez passer start , stop , et step arguments auquel cas l'objet range ira de start à step en utilisant le step donné Taille. Par exemple, range(3) résultats en 0, 1, 2 et range(2, 7, 2) résultats en 2, 4, 6 .
>>> range(10) range(0, 10) >>> print(range(10)) range(0, 10) >>> print(*range(10)) 0 1 2 3 4 5 6 7 8 9 >>> range(1, 10, 3) range(1, 10, 3) >>> print(*range(1, 10, 3)) 1 4 7
len()
La fonction intégrée de Python len() renvoie la longueur de la chaîne, du tableau, de la liste, du tuple, du dictionnaire ou de tout autre itérable donné. Le type de la valeur de retour est un entier qui représente le nombre d'éléments dans cet itérable.
>>> friends = ['Alice', 'Bob', 'Carl', 'Ann']
>>> len(friends)
4
>>> friends.extend([1, 2, 3])
>>> len(friends)
7
>>> len('hello world')
11
>>> len('hi')
2
>>> len((1, 2, 3))
3
>>> len({42, 21})
2
>>> age = {'Alice': 18, 'Bob': 21}
>>> len(age)
2
>>> age['Carl'] = 33
>>> len(age)
3
max()
Le max() La fonction renvoie le maximum des arguments fournis. Vous pouvez passer soit un nombre arbitraire de valeurs, séparées par des virgules, soit un itérable comme arguments. Un key facultatif L'argument de la fonction vous permet de personnaliser le calcul du maximum en définissant explicitement le poids de chaque valeur dans l'itérable qui est utilisé comme base de comparaison.
>>> max(1, 2, 3) 3 >>> max(1, 2, 3, key = lambda x: -x) 1
min()
Le min() La fonction renvoie le minimum des arguments fournis. En tant qu'arguments, vous pouvez soit passer un certain nombre de valeurs séparées par des virgules, soit un seul itérable. Un key facultatif L'argument de la fonction vous permet de personnaliser le calcul du minimum en définissant explicitement le poids de chaque valeur dans l'itérable qui est utilisé comme base de comparaison.
>>> min(1, 2, 3) 1 >>> min(1, 2, 3, key = lambda x: -x) 3
Chaque maître Python comprend très bien les bases. Les fonctions intégrées de Python sont la base même de toute votre carrière de codage. Pour un cours complet sur les 64 fonctions intégrées de Python, consultez la Finxter Computer Science Academy :
sum()
Pour vous aider à accomplir cette tâche de manière concise, lisible et efficace, les créateurs de Python ont ajouté le sum() intégré fonction. Il additionne tous les éléments d'une liste Python, ou tout autre itérable d'ailleurs.
lst = [1, 2, 3, 4, 5, 6] print(sum(lst)) # 21 print(sum(lst, 10)) # 31
slice()
slice() intégré de Python renvoie un nouvel objet slice que vous pouvez utiliser pour découper des séquences telles que des listes, des chaînes ou des tuples.
>>> lst =list(range(20)) >>> lst [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] >>> s = slice(10) >>> lst[s] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> lst =list(range(20)) >>> s = slice(2, 10, 2) >>> lst[s] [2, 4, 6, 8]
enumerate()
enumerate(iterable) intégré de Python la fonction vous permet de boucler sur tous les éléments d'un iterable et leurs compteurs associés. Formellement, il faut un iterable comme argument d'entrée et retourne un itérable de tuples (i, x) —un par élément itérable x . La première valeur de tuple entier est le compteur de l'élément x dans le iterable , en commençant à compter à partir de 0. La deuxième valeur de tuple est une référence à l'élément x lui-même. Par exemple, enumerate(['a', 'b', 'c']) renvoie un (0, 'a'), (1, 'b'), (2, 'c') itérable . Vous pouvez modifier l'index de départ du compteur par défaut en définissant le deuxième argument entier facultatif enumerate(iterable, start) .
fruits = ['apple', 'banana', 'cherry']
for counter, value in enumerate(fruits):
print(counter, value)
# OUTPUT:
# 0 apple
# 1 banana
# 2 cherry
reversed()
reversed(sequence) intégré de Python La fonction renvoie un itérateur inverse sur les valeurs de la séquence donnée, telle qu'une liste, un tuple ou une chaîne.
>>> list(reversed([1, 2, 3])) [3, 2, 1] >>> tuple(reversed([1, 2, 3])) (3, 2, 1)
Chaque maître Python comprend très bien les bases. Les fonctions intégrées de Python sont la base même de toute votre carrière de codage. Pour un cours complet sur les 64 fonctions intégrées de Python, consultez la Finxter Computer Science Academy :
sorted()
Le sorted() La fonction prend une entrée itérable spécifiée et renvoie une liste triée.
>>> x = [4, 1, 2] >>> sorted(x) [1, 2, 4]
filter()
filter() intégré de Python La fonction est utilisée pour filtrer les éléments qui passent une condition de filtrage. Il prend deux arguments :function et iterable . Le function attribue une valeur booléenne à chaque élément du iterable pour vérifier si l'élément passera ou non le filtre. Il renvoie un itérateur avec les éléments qui passent la condition de filtrage.
lst = [8, 2, 6, 4, 3, 1] # Filter all elements <8 small = filter(lambda x: x<8, lst) print(list(small)) # Filter all even elements even = filter(lambda x: x%2==0, lst) print(list(even)) # Filter all odd elements odd = filter(lambda x: x%2, lst) print(list(odd))
map()
>>> m = map(lambda x: 42, [1, 2, 3]) >>> type(m) <class 'map'>
any()
Le zip() La fonction prend un nombre arbitraire d'itérables et les agrège en un seul itérable, un objet zip. Il combine les i-ièmes valeurs de chaque argument itérable dans un tuple. Par conséquent, si vous passez deux itérables, chaque tuple contiendra deux valeurs. Si vous passez trois itérables, chaque tuple contiendra trois valeurs. Par exemple, zip ensemble répertorie [1, 2, 3] et [4, 5, 6] à [(1,4), (2,5), (3,6)] .
# Boolean list with False value print(any([True, False, True, True])) # True # Boolean list without False value print(any([True, True])) # True # Integer list with 0 value print(any([1, 2, -1, 0])) # True # Integer list without 0 value print(any([1, 2, -1])) # True # Nested list with empty inner list print(any([[], [1, 2, 3]])) # True # Nested list with two empty inner lists print(any([[], []])) # False # Empty List print(any([])) # False
all()
Le zip() La fonction prend un nombre arbitraire d'itérables et les agrège en un seul itérable, un objet zip. Il combine les i-ièmes valeurs de chaque argument itérable dans un tuple. Par conséquent, si vous passez deux itérables, chaque tuple contiendra deux valeurs. Si vous passez trois itérables, chaque tuple contiendra trois valeurs. Par exemple, zip ensemble répertorie [1, 2, 3] et [4, 5, 6] à [(1,4), (2,5), (3,6)] .
# Boolean list with False value print(all([True, False, True, True])) # False # Boolean list without False value print(all([True, True])) # True # Integer list with 0 value print(all([1, 2, -1, 0])) # False # Integer list without 0 value print(all([1, 2, -1])) # True # List of Lists with empty inner list print(all([[], [1, 2, 3]])) # False # List of Lists without empty inner list print(all([[1, 2, 3], [4, 5]])) # True # Empty List print(all([])) # True
zip()
Le zip() La fonction prend un nombre arbitraire d'itérables et les agrège en un seul itérable, un objet zip. Il combine les i-ièmes valeurs de chaque argument itérable dans un tuple. Par conséquent, si vous passez deux itérables, chaque tuple contiendra deux valeurs. Si vous passez trois itérables, chaque tuple contiendra trois valeurs. Par exemple, zip ensemble répertorie [1, 2, 3] et [4, 5, 6] à [(1,4), (2,5), (3,6)] .
lst_1 = [1, 2, 3] lst_2 = [4, 5, 6] # Zip two lists together zipped = list(zip(lst_1, lst_2)) print(zipped) # [(1, 4), (2, 5), (3, 6)] # Unzip to lists again lst_1_new, lst_2_new = zip(*zipped) print(list(lst_1_new)) print(list(lst_2_new))
Chaque maître Python comprend très bien les bases. Les fonctions intégrées de Python sont la base même de toute votre carrière de codage. Pour un cours complet sur les 64 fonctions intégrées de Python, consultez la Finxter Computer Science Academy :
