Types de données de base en Python

Vous connaissez maintenanthow to interact with the Python interpreter and execute Python code. Il est temps de creuser dans le langage Python. Le premier est une discussion sur les types de données de base qui sont intégrés dans Python.

Voici ce que vous apprendrez dans ce didacticiel:

Vous découvrirez plusieurs types de basenumeric, string etBoolean intégrés à Python. À la fin de ce didacticiel, vous saurez à quoi ressemblent les objets de ces types et comment les représenter.
Vous obtiendrez également un aperçu desfunctions. intégrés à Python. Ce sont des morceaux de code pré-écrits que vous pouvez appeler pour faire des choses utiles. Vous avez déjà vu la fonction intégréeprint(), mais il y en a beaucoup d'autres.

Téléchargement PDF gratuit: Aide-mémoire Python 3

__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Types de données de base en Python». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:

Fais le quiz "

Entiers

En Python 3, il n'y a en fait aucune limite à la longueur d'une valeur entière. Bien sûr, il est limité par la quantité de mémoire de votre système, comme toutes choses, mais au-delà, un entier peut être aussi long que vous en avez besoin:

>>>

>>> print(123123123123123123123123123123123123123123123123 + 1)
123123123123123123123123123123123123123123123124

Python interprète une séquence de chiffres décimaux sans aucun préfixe comme un nombre décimal:

>>>

>>> print(10)
10

Les chaînes suivantes peuvent être ajoutées à une valeur entière pour indiquer une base autre que 10:

Préfixe Interprétation Base

Préfixe	Interprétation	Base
`0b` (zéro + lettre minuscule`'b'`) `0B` (zéro + lettre majuscule`'B'`)	Binaire	2
`0o` (zéro + lettre minuscule`'o'`) `0O` (zéro + lettre majuscule`'O'`)	Octal	8
`0x` (zéro + lettre minuscule`'x'`) `0X` (zéro + lettre majuscule`'X'`)	Hexadécimal	16

0b (zéro + lettre minuscule'b')
0B (zéro + lettre majuscule'B')

Binaire

0o (zéro + lettre minuscule'o')
0O (zéro + lettre majuscule'O')

Octal

0x (zéro + lettre minuscule'x')
0X (zéro + lettre majuscule'X')

Hexadécimal

Par exemple:

>>>

>>> print(0o10)
8

>>> print(0x10)
16

>>> print(0b10)
2

Pour plus d'informations sur les valeurs entières avec des bases non décimales, consultez les sites Wikipédia suivants:Binary,Octal etHexadecimal.

Le type sous-jacent d'un entier Python, quelle que soit la base utilisée pour le spécifier, est appeléint:

>>>

>>> type(10)

>>> type(0o10)

>>> type(0x10)

Note: C'est le bon moment pour mentionner que si vous souhaitez afficher une valeur pendant une session REPL, vous n'avez pas besoin d'utiliser la fonctionprint(). Tapez simplement la valeur à l'invite>>> et appuyez sur[.kbd .key-enter]#Enter # pour l'afficher:

>>>

>>> 10
10
>>> 0x10
16
>>> 0b10
2

De nombreux exemples de cette série de didacticiels utiliseront cette fonctionnalité.

Notez que cela ne fonctionne pas dans un fichier script. Une valeur apparaissant seule sur une ligne dans un fichier script ne fera rien.

Nombres à virgule flottante

Le typefloat en Python désigne un nombre à virgule flottante. Les valeursfloat sont spécifiées avec un point décimal. Facultativement, le caractèree ouE suivi d'un entier positif ou négatif peut être ajouté pour spécifierscientific notation:

>>>

>>> 4.2
4.2
>>> type(4.2)

>>> 4.
4.0
>>> .2
0.2

>>> .4e7
4000000.0
>>> type(.4e7)

>>> 4.2e-4
0.00042

Deep Dive: représentation en virgule flottante

Ce qui suit est un peu plus d'informations sur la façon dont Python représente les nombres à virgule flottante en interne. Vous pouvez facilement utiliser des nombres à virgule flottante en Python sans les comprendre à ce niveau, alors ne vous inquiétez pas si cela semble trop compliqué. Les informations sont présentées ici au cas où vous seriez curieux.

Presque toutes les plates-formes représentent les valeurs Pythonfloat sous forme de valeurs 64 bits «double précision», selon la normeIEEE 754. Dans ce cas, la valeur maximale qu'un nombre à virgule flottante peut avoir est d'environ 1,8 ⨉ 10³⁰⁸. Python indiquera un nombre supérieur à celui de la chaîneinf:

>>>
>>> 1.79e308
1.79e+308
>>> 1.8e308
inf
Le nombre différent de zéro le plus proche de zéro est d'environ 5,0 ⨉ 10^-324. Tout ce qui est plus proche de zéro que cela est effectivement nul:

>>>
>>> 5e-324
5e-324
>>> 1e-325
0.0
Les nombres à virgule flottante sont représentés en interne sous forme de fractions binaires (base-2). La plupart des fractions décimales ne peuvent pas être représentées exactement comme des fractions binaires, donc dans la plupart des cas, la représentation interne d'un nombre à virgule flottante est une approximation de la valeur réelle. En pratique, la différence entre la valeur réelle et la valeur représentée est très faible et ne devrait généralement pas poser de problèmes importants.

Further Reading: Pour plus d'informations sur la représentation en virgule flottante en Python et les pièges potentiels impliqués, consultezFloating Point Arithmetic: Issues and Limitations dans la documentation Python.

Nombres complexes

Les nombres complexes sont spécifiés en<real part>+<imaginary part>j. Par exemple:

>>>

>>> 2+3j
(2+3j)
>>> type(2+3j)

Les cordes

Les chaînes sont des séquences de données de caractères. Le type de chaîne en Python est appeléstr.

Les littéraux de chaîne peuvent être délimités à l'aide de guillemets simples ou doubles. Tous les caractères entre le délimiteur d'ouverture et le délimiteur de fermeture correspondant font partie de la chaîne:

>>>

>>> print("I am a string.")
I am a string.
>>> type("I am a string.")


>>> print('I am too.')
I am too.
>>> type('I am too.')

Une chaîne en Python peut contenir autant de caractères que vous le souhaitez. La seule limite est les ressources mémoire de votre machine. Une chaîne peut également être vide:

>>>

>>> ''
''

Que faire si vous souhaitez inclure un caractère de citation dans la chaîne elle-même? Votre première impulsion pourrait être d'essayer quelque chose comme ceci:

>>>

>>> print('This string contains a single quote (') character.')
SyntaxError: invalid syntax

Comme vous pouvez le voir, cela ne fonctionne pas si bien. La chaîne de cet exemple s'ouvre avec un guillemet simple, donc Python suppose que le guillemet simple suivant, celui entre parenthèses qui devait faire partie de la chaîne, est le délimiteur de fermeture. Le guillemet final final est alors un parasite et provoque l'erreur de syntaxe indiquée.

Si vous souhaitez inclure l'un ou l'autre type de guillemet dans la chaîne, le moyen le plus simple consiste à délimiter la chaîne avec l'autre type. Si une chaîne doit contenir un guillemet simple, délimitez-la avec des guillemets doubles et vice versa:

>>>

>>> print("This string contains a single quote (') character.")
This string contains a single quote (') character.

>>> print('This string contains a double quote (") character.')
This string contains a double quote (") character.

Séquences d'échappement dans les chaînes

Parfois, vous voulez que Python interprète différemment un caractère ou une séquence de caractères dans une chaîne. Cela peut se produire de deux manières:

Vous souhaiterez peut-être supprimer l'interprétation spéciale selon laquelle certains caractères sont généralement donnés dans une chaîne.
Vous souhaiterez peut-être appliquer une interprétation spéciale aux caractères d'une chaîne qui serait normalement prise à la lettre.

Vous pouvez accomplir cela en utilisant une barre oblique inverse (\). Une barre oblique inversée dans une chaîne indique qu'un ou plusieurs caractères qui la suivent doivent être traités spécialement. (Ceci est appelé une séquence d'échappement, car la barre oblique inverse fait que la séquence de caractères suivante «échappe» à sa signification habituelle.)

Voyons comment cela fonctionne.

Suppression des caractères spéciaux Signification

Vous avez déjà vu les problèmes que vous pouvez rencontrer lorsque vous essayez d'inclure des guillemets dans une chaîne. Si une chaîne est délimitée par des guillemets simples, vous ne pouvez pas spécifier directement un seul caractère de guillemet dans le cadre de la chaîne, car, pour cette chaîne, le guillemet simple a une signification particulière — il termine la chaîne:

>>>

>>> print('This string contains a single quote (') character.')
SyntaxError: invalid syntax

La spécification d'une barre oblique inverse devant le caractère guillemet dans une chaîne «l'échappe» et fait que Python supprime sa signification spéciale habituelle. Il est alors interprété simplement comme un caractère de guillemet simple littéral:

>>>

>>> print('This string contains a single quote (\') character.')
This string contains a single quote (') character.

La même chose fonctionne également dans une chaîne délimitée par des guillemets doubles:

>>>

>>> print("This string contains a double quote (\") character.")
This string contains a double quote (") character.

Ce qui suit est un tableau de séquences d'échappement qui font que Python supprime l'interprétation spéciale habituelle d'un caractère dans une chaîne:

Séquence d'échappement Interprétation habituelle des caractères
après la barre oblique inverse Interprétation «échappé»

Séquence d'échappement	Interprétation habituelle des caractères après la barre oblique inverse	Interprétation «échappé»
`\'`	Termine la chaîne avec un séparateur d'ouverture entre guillemets simples	Guillemet simple littéral (`'`) caractère
`\"`	Termine la chaîne avec un séparateur d'ouverture entre guillemets	Guillemet double littéral (`"`) caractère
`\newline`	Termine la ligne d'entrée	La nouvelle ligne est ignorée
`\\`	Introduit la séquence d'échappement	Barre oblique inverse littérale (`\`) caractère

\'

Termine la chaîne avec un séparateur d'ouverture entre guillemets simples

Guillemet simple littéral (') caractère

\"

Termine la chaîne avec un séparateur d'ouverture entre guillemets

Guillemet double littéral (") caractère

\newline

Termine la ligne d'entrée

La nouvelle ligne est ignorée

\\

Introduit la séquence d'échappement

Barre oblique inverse littérale (\) caractère

Normalement, un caractère de nouvelle ligne termine la saisie de ligne. Donc, appuyer sur[.kbd .key-enter]#Enter # au milieu d'une chaîne fera penser à Python qu'il est incomplet:

>>>

>>> print('a

SyntaxError: EOL while scanning string literal

Pour fractionner une chaîne sur plusieurs lignes, incluez une barre oblique inverse avant chaque nouvelle ligne, et les nouvelles lignes seront ignorées:

>>>

>>> print('a\
... b\
... c')
abc

Pour inclure une barre oblique inverse littérale dans une chaîne, échappez-la avec une barre oblique inverse:

>>>

>>> print('foo\\bar')
foo\bar

Application d'une signification spéciale aux caractères

Supposez ensuite que vous devez créer une chaîne contenant un caractère de tabulation. Certains éditeurs de texte peuvent vous permettre d'insérer un caractère de tabulation directement dans votre code. Mais de nombreux programmeurs considèrent cette mauvaise pratique, pour plusieurs raisons:

L'ordinateur peut faire la distinction entre un caractère de tabulation et une séquence de caractères d'espacement, mais vous ne pouvez pas. Pour un humain qui lit le code, les caractères de tabulation et d'espace sont visuellement indiscernables.
Certains éditeurs de texte sont configurés pour éliminer automatiquement les caractères de tabulation en les étendant au nombre approprié d'espaces.
Certains environnements Python REPL n'insèrent pas d'onglets dans le code.

En Python (et presque tous les autres langages informatiques courants), un caractère de tabulation peut être spécifié par la séquence d'échappement :

>>>

>>> print('foo\tbar')
foo     bar

La séquence d'échappement fait perdre au caractèret sa signification habituelle, celle d'un littéralt. Au lieu de cela, la combinaison est interprétée comme un caractère de tabulation.

Voici une liste de séquences d'échappement qui font que Python applique une signification spéciale au lieu d'interpréter littéralement:

Séquence d'échappement Interprétation «échappé»

Séquence d'échappement	Interprétation «échappé»
`\a`	Caractère ASCII Bell (`BEL`)
`\b`	Caractère ASCII Backspace (`BS`)
`\f`	ASCII Formfeed (`FF`) caractère
`\n`	Saut de ligne ASCII (`LF`) caractère
`\N{}`	Caractère de la base de données Unicode avec des`<name>` donnés
`\r`	Caractère ASCII de retour chariot (`CR`)
`\t`	Tabulation horizontale ASCII (`TAB`) caractère
`\uxxxx`	Caractère Unicode avec valeur hexadécimale de 16 bits`xxxx`
`\Uxxxxxxxx`	Caractère Unicode avec une valeur hexadécimale 32 bits`xxxxxxxx`
`\v`	Tabulation verticale ASCII (`VT`) caractère
`\oxx`	Caractère avec valeur octale`xx`
`\xhh`	Caractère avec valeur hexadécimale`hh`

\a

Caractère ASCII Bell (BEL)

\b

Caractère ASCII Backspace (BS)

\f

ASCII Formfeed (FF) caractère

\n

Saut de ligne ASCII (LF) caractère

\N{}

Caractère de la base de données Unicode avec des<name> donnés

\r

Caractère ASCII de retour chariot (CR)

\t

Tabulation horizontale ASCII (TAB) caractère

\uxxxx

Caractère Unicode avec valeur hexadécimale de 16 bitsxxxx

\Uxxxxxxxx

Caractère Unicode avec une valeur hexadécimale 32 bitsxxxxxxxx

\v

Tabulation verticale ASCII (VT) caractère

\oxx

Caractère avec valeur octalexx

\xhh

Caractère avec valeur hexadécimalehh

Exemples:

>>>

>>> print("a\tb")
a    b
>>> print("a\141\x61")
aaa
>>> print("a\nb")
a
b
>>> print('\u2192 \N{rightwards arrow}')
→ →

Ce type de séquence d'échappement est généralement utilisé pour insérer des caractères qui ne sont pas facilement générés à partir du clavier ou qui ne sont pas facilement lisibles ou imprimables.

Cordes brutes

Un littéral de chaîne brute est précédé der ouR, ce qui spécifie que les séquences d'échappement dans la chaîne associée ne sont pas traduites. Le caractère barre oblique inverse est laissé dans la chaîne:

>>>

>>> print('foo\nbar')
foo
bar
>>> print(r'foo\nbar')
foo\nbar

>>> print('foo\\bar')
foo\bar
>>> print(R'foo\\bar')
foo\\bar

Chaînes à guillemets triples

Il existe encore une autre façon de délimiter les chaînes en Python. Les chaînes entre guillemets triples sont délimitées par des groupes de correspondance de trois guillemets simples ou de trois guillemets doubles. Les séquences d'échappement fonctionnent toujours dans les chaînes entre guillemets triples, mais les guillemets simples, les guillemets doubles et les retours à la ligne peuvent être inclus sans les échapper. Cela fournit un moyen pratique de créer une chaîne avec des guillemets simples et doubles:

>>>

>>> print('''This string has a single (') and a double (") quote.''')
This string has a single (') and a double (") quote.

Parce que les sauts de ligne peuvent être inclus sans les échapper, cela permet également des chaînes multilignes:

>>>

>>> print("""This is a
string that spans
across several lines""")
This is a
string that spans
across several lines

Vous verrez dans le prochain tutoriel sur la structure du programme Python comment les chaînes entre guillemets triples peuvent être utilisées pour ajouter un commentaire explicatif au code Python.

Type booléen, contexte booléen et «véracité»

Python 3 fournit un type de données booléen. Les objets de type booléen peuvent avoir l'une des deux valeurs,True ouFalse:

>>>

>>> type(True)

>>> type(False)

Comme vous le verrez dans les prochains tutoriels, les expressions en Python sont souvent évaluées dans un contexte booléen, ce qui signifie qu'elles sont interprétées comme représentant la vérité ou le mensonge. Une valeur vraie dans le contexte booléen est parfois dite «véridique», et une valeur fausse dans le contexte booléen est dite «fausse». (Vous pouvez également voir «fausse» orthographié «falsey».)

La «véracité» d'un objet de type booléen va de soi: les objets booléens égaux àTrue sont vrais (vrais) et ceux égaux àFalse sont faux (faux). Mais les objets non booléens peuvent également être évalués dans un contexte booléen et déterminés comme vrais ou faux.

Vous en apprendrez plus sur l'évaluation des objets en contexte booléen lorsque vous rencontrerez des opérateurs logiques dans le prochain tutoriel sur les opérateurs et les expressions en Python.

Fonctions intégrées

L'interpréteur Python prend en charge de nombreuses fonctions intégrées: soixante-huit, à partir de Python 3.6. Vous en couvrirez un grand nombre dans les discussions suivantes, dans leur contexte.

Pour l'instant, un bref aperçu suit, juste pour donner une idée de ce qui est disponible. Voir lesPython documentation on built-in functions pour plus de détails. La plupart des descriptions suivantes font référence à des rubriques et concepts qui seront abordés dans les futurs didacticiels.

Math

Une fonction La description

Une fonction	La description
`abs()`	Renvoie la valeur absolue d'un nombre
`divmod()`	Renvoie le quotient et le reste de la division entière
`max()`	Renvoie le plus grand des arguments ou éléments donnés dans un itérable
`min()`	Renvoie le plus petit des arguments ou éléments donnés dans un itérable
`pow()`	Élève un nombre à une puissance
`round()`	Arrondit une valeur à virgule flottante
`sum()`	Somme les éléments d'un itérable

abs()

Renvoie la valeur absolue d'un nombre

divmod()

Renvoie le quotient et le reste de la division entière

max()

Renvoie le plus grand des arguments ou éléments donnés dans un itérable

min()

Renvoie le plus petit des arguments ou éléments donnés dans un itérable

pow()

Élève un nombre à une puissance

round()

Arrondit une valeur à virgule flottante

sum()

Somme les éléments d'un itérable

Conversion de type

Une fonction La description

Une fonction	La description
`ascii()`	Renvoie une chaîne contenant une représentation imprimable d'un objet
`bin()`	Convertit un entier en chaîne binaire
`bool()`	Convertit un argument en valeur booléenne
`chr()`	Renvoie une représentation sous forme de chaîne d'un caractère donné par un argument entier
`complex()`	Renvoie un nombre complexe construit à partir d'arguments
`float()`	Renvoie un objet à virgule flottante construit à partir d'un nombre ou d'une chaîne
`hex()`	Convertit un entier en chaîne hexadécimale
`int()`	Renvoie un objet entier construit à partir d'un nombre ou d'une chaîne
`oct()`	Convertit un entier en une chaîne octale
`ord()`	Renvoie une représentation entière d'un caractère
`repr()`	Renvoie une chaîne contenant une représentation imprimable d'un objet
`str()`	Renvoie une version chaîne d'un objet
`type()`	Renvoie le type d'un objet ou crée un nouvel objet de type

ascii()

Renvoie une chaîne contenant une représentation imprimable d'un objet

bin()

Convertit un entier en chaîne binaire

bool()

Convertit un argument en valeur booléenne

chr()

Renvoie une représentation sous forme de chaîne d'un caractère donné par un argument entier

complex()

Renvoie un nombre complexe construit à partir d'arguments

float()

Renvoie un objet à virgule flottante construit à partir d'un nombre ou d'une chaîne

hex()

Convertit un entier en chaîne hexadécimale

int()

Renvoie un objet entier construit à partir d'un nombre ou d'une chaîne

oct()

Convertit un entier en une chaîne octale

ord()

Renvoie une représentation entière d'un caractère

repr()

Renvoie une chaîne contenant une représentation imprimable d'un objet

str()

Renvoie une version chaîne d'un objet

type()

Renvoie le type d'un objet ou crée un nouvel objet de type

Iterables et itérateurs

Une fonction La description

Une fonction	La description
`all()`	Renvoie`True` si tous les éléments d'un itérable sont vrais
`any()`	Renvoie`True` si l'un des éléments d'un itérable est vrai
`enumerate()`	Renvoie une liste de tuples contenant des indices et des valeurs d'un itérable
`filter()`	Filtre les éléments d'un itérable
`iter()`	Renvoie un objet itérateur
`len()`	Renvoie la longueur d'un objet
`map()`	Applique une fonction à chaque élément d'un itérable
`next()`	Récupère l'élément suivant d'un itérateur
`range()`	Génère une plage de valeurs entières
`reversed()`	Renvoie un itérateur inversé
`slice()`	Renvoie un objet`slice`
`sorted()`	Renvoie une liste triée à partir d'un itérable
`zip()`	Crée un itérateur qui agrège les éléments des itérables

all()

RenvoieTrue si tous les éléments d'un itérable sont vrais

any()

RenvoieTrue si l'un des éléments d'un itérable est vrai

enumerate()

Renvoie une liste de tuples contenant des indices et des valeurs d'un itérable

filter()

Filtre les éléments d'un itérable

iter()

Renvoie un objet itérateur

len()

Renvoie la longueur d'un objet

map()

Applique une fonction à chaque élément d'un itérable

next()

Récupère l'élément suivant d'un itérateur

range()

Génère une plage de valeurs entières

reversed()

Renvoie un itérateur inversé

slice()

Renvoie un objetslice

sorted()

Renvoie une liste triée à partir d'un itérable

zip()

Crée un itérateur qui agrège les éléments des itérables

Type de données composite

Une fonction La description

Une fonction	La description
`bytearray()`	Crée et renvoie un objet de la classe`bytearray`
`bytes()`	Crée et renvoie un objet`bytes` (similaire à`bytearray`, mais immuable)
`dict()`	Crée un objet`dict`
`frozenset()`	Crée un objet`frozenset`
`list()`	Construit un objet`list`
`object()`	Renvoie un nouvel objet sans caractéristique
`set()`	Crée un objet`set`
`tuple()`	Crée un objet`tuple`

bytearray()

Crée et renvoie un objet de la classebytearray

bytes()

Crée et renvoie un objetbytes (similaire àbytearray, mais immuable)

dict()

Crée un objetdict

frozenset()

Crée un objetfrozenset

list()

Construit un objetlist

object()

Renvoie un nouvel objet sans caractéristique

set()

Crée un objetset

tuple()

Crée un objettuple

Classes, attributs et héritage

Une fonction La description

Une fonction	La description
`classmethod()`	Renvoie une méthode de classe pour une fonction
`delattr()`	Supprime un attribut d'un objet
`getattr()`	Renvoie la valeur d'un attribut nommé d'un objet
`hasattr()`	Renvoie`True` si un objet a un attribut donné
`isinstance()`	Détermine si un objet est une instance d'une classe donnée
`issubclass()`	Détermine si une classe est une sous-classe d'une classe donnée
`property()`	Renvoie une valeur de propriété d'une classe
`setattr()`	Définit la valeur d'un attribut nommé d'un objet
`super()`	Renvoie un objet proxy qui délègue les appels de méthode à une classe parent ou sœur

classmethod()

Renvoie une méthode de classe pour une fonction

delattr()

Supprime un attribut d'un objet

getattr()

Renvoie la valeur d'un attribut nommé d'un objet

hasattr()

RenvoieTrue si un objet a un attribut donné

isinstance()

Détermine si un objet est une instance d'une classe donnée

issubclass()

Détermine si une classe est une sous-classe d'une classe donnée

property()

Renvoie une valeur de propriété d'une classe

setattr()

Définit la valeur d'un attribut nommé d'un objet

super()

Renvoie un objet proxy qui délègue les appels de méthode à une classe parent ou sœur

Input/Output

Une fonction La description

Une fonction	La description
`format()`	Convertit une valeur en une représentation formatée
`input()`	Lit les entrées de la console
`open()`	Ouvre un fichier et renvoie un objet fichier
`print()`	Imprime sur un flux de texte ou sur la console

format()

Convertit une valeur en une représentation formatée

input()

Lit les entrées de la console

open()

Ouvre un fichier et renvoie un objet fichier

print()

Imprime sur un flux de texte ou sur la console

Variables, références et portée

Une fonction La description

Une fonction	La description
`dir()`	Renvoie une liste de noms dans la portée locale actuelle ou une liste d'attributs d'objet
`globals()`	Renvoie un dictionnaire représentant la table de symboles globale actuelle
`id()`	Renvoie l'identité d'un objet
`locals()`	Met à jour et renvoie un dictionnaire représentant la table de symboles locale actuelle
`vars()`	Renvoie l'attribut`__dict__` pour un module, une classe ou un objet

dir()

Renvoie une liste de noms dans la portée locale actuelle ou une liste d'attributs d'objet

globals()

Renvoie un dictionnaire représentant la table de symboles globale actuelle

id()

Renvoie l'identité d'un objet

locals()

Met à jour et renvoie un dictionnaire représentant la table de symboles locale actuelle

vars()

Renvoie l'attribut__dict__ pour un module, une classe ou un objet

Divers

Une fonction La description

Une fonction	La description
`callable()`	Renvoie`True` si l'objet semble appelable
`compile()`	Compile la source dans un code ou un objet AST
`eval()`	Évalue une expression Python
`exec()`	Implémente l'exécution dynamique du code Python
`hash()`	Renvoie la valeur de hachage d'un objet
`help()`	Invoque le système d'aide intégré
`memoryview()`	Renvoie un objet de vue mémoire
`staticmethod()`	Renvoie une méthode statique pour une fonction
`__import__()`	Appelé par l'instruction`import`

callable()

RenvoieTrue si l'objet semble appelable

compile()

Compile la source dans un code ou un objet AST

eval()

Évalue une expression Python

exec()

Implémente l'exécution dynamique du code Python

hash()

Renvoie la valeur de hachage d'un objet

help()

Invoque le système d'aide intégré

memoryview()

Renvoie un objet de vue mémoire

staticmethod()

Renvoie une méthode statique pour une fonction

__import__()

Appelé par l'instructionimport

Conclusion

Dans ce didacticiel, vous avez découvert lesdata types etfunctions intégrés fournis par Python.

Les exemples donnés jusqu'à présent ont tous été manipulés et n'ont affiché que des valeurs constantes. Dans la plupart des programmes, vous souhaiterez généralement créer des objets dont la valeur change à mesure que le programme s'exécute.

Accédez au didacticiel suivant pour en savoir plus sur Pythonvariables.

Fais le quiz "

TOC

Types de données de base en Python