Python Language Types de données


Exemple

Types intégrés

Booléens

bool : Une valeur booléenne de True ou False . Les opérations logiques comme and or not peuvent not être effectuées sur des booléens.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

Dans Python 2.x et dans Python 3.x, un booléen est aussi un int . Le type bool est une sous-classe du type int et True et False sont ses seules instances:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

Si des valeurs booléennes sont utilisées dans les opérations arithmétiques, leurs valeurs entières ( 1 et 0 pour True et False ) seront utilisées pour renvoyer un résultat entier:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

Nombres

  • int : nombre entier

    a = 2
    b = 100
    c = 123456789
    d = 38563846326424324
    

    Les entiers en Python sont de tailles arbitraires.

    Remarque: dans les anciennes versions de Python, un type long était disponible, distinct de int . Les deux ont été unifiés.

  • float : nombre à virgule flottante; la précision dépend de l'implémentation et de l'architecture du système, pour CPython, le type de données float correspond à un double C.

    a = 2.0
    b = 100.e0
    c = 123456789.e1
    
  • complex : nombres complexes

    a = 2 + 1j
    b = 100 + 10j
    

Les opérateurs < , <= , > et >= TypeError une exception TypeError quand un opérande est un nombre complexe.

Cordes

Python 3.x 3.0
  • str : une chaîne Unicode . Le type de 'hello'
  • bytes : une chaîne d'octets . Le type de b'hello'
Python 2.x 2.7
  • str : une chaîne d'octets . Le type de 'hello'
  • bytes : synonyme de str
  • unicode : une chaîne Unicode . Le type de u'hello'

Séquences et collections

Python différencie les séquences ordonnées et les collections non ordonnées (telles que set et dict ).

  • les chaînes ( str , bytes , unicode ) sont des séquences

  • reversed : ordre inverse de str avec fonction reversed

    a = reversed('hello')
    
  • tuple : Collection ordonnée de n valeurs de tout type ( n >= 0 ).

    a = (1, 2, 3)
    b = ('a', 1, 'python', (1, 2))
    b[2] = 'something else' # returns a TypeError
    

    Supporte l'indexation immuable; hashable si tous ses membres sont lavables

  • list : Une collection ordonnée de n valeurs ( n >= 0 )

    a = [1, 2, 3]
    b = ['a', 1, 'python', (1, 2), [1, 2]]
    b[2] = 'something else' # allowed
    

    Non lavable; mutable.

  • set : Une collection non ordonnée de valeurs uniques. Les articles doivent être lavables .

    a = {1, 2, 'a'}
    
  • dict : Une collection non ordonnée de paires clé-valeur uniques; les clés doivent être lavables .

    a = {1: 'one',
         2: 'two'}
    
    b = {'a': [1, 2, 3],
         'b': 'a string'}
    

Un objet est hashrable s'il a une valeur de hachage qui ne change jamais au cours de sa vie (il a besoin d'une __hash__() ) et peut être comparé à d'autres objets (il nécessite une __eq__() ). Les objets lavables qui comparent l'égalité doivent avoir la même valeur de hachage.

Constantes intégrées

En conjonction avec les types de données intégrés, il existe un petit nombre de constantes intégrées dans l'espace de noms intégré:

  • True : La valeur réelle du type intégré bool
  • False : La valeur false du type intégré bool
  • None : objet singleton utilisé pour signaler qu'une valeur est absente.
  • Ellipsis ou ... : utilisé dans Python3 + de base n'importe où et utilisation limitée dans Python2.7 + dans le cadre de la notation de tableau. numpy et les paquets associés l'utilisent comme référence "include everything" dans les tableaux.
  • NotImplemented : un singleton utilisé pour indiquer à Python qu'une méthode spéciale ne prend pas en charge les arguments spécifiques, et Python essaiera des alternatives si elles sont disponibles.
a = None # No value will be assigned. Any valid datatype can be assigned later
Python 3.x 3.0

None n'a aucun ordre naturel. L'utilisation des opérateurs de comparaison de commandes ( < , <= , >= , > ) n'est plus prise en charge et TypeError une TypeError .

Python 2.x 2.7

None n'est toujours inférieur à aucun nombre ( None < -32 None vaut True ).

Test du type de variables

En python, nous pouvons vérifier le type de données d'un objet en utilisant le type fonction intégré.

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

Dans les instructions conditionnelles, il est possible de tester le type de données avec isinstance . Cependant, il n'est généralement pas recommandé de compter sur le type de la variable.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

Pour plus d'informations sur les différences entre type() et isinstance() lisez: Différences entre isinstance et type dans Python

Pour tester si quelque chose est de NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

Conversion entre types de données

Vous pouvez effectuer une conversion de type de données explicite.

Par exemple, '123' est de type str et peut être converti en entier en utilisant la fonction int .

a = '123'
b = int(a)

La conversion à partir d'une chaîne de caractères telle que «123.456» peut être effectuée à l'aide de la fonction float .

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

Vous pouvez également convertir des types de séquence ou de collection

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Type de chaîne explicite à la définition des littéraux

Avec des étiquettes d'une lettre juste devant les guillemets, vous pouvez indiquer le type de chaîne que vous souhaitez définir.

  • b'foo bar' : bytes résultats dans Python 3, str dans Python 2
  • u'foo bar' : résultats str dans Python 3, unicode dans Python 2
  • 'foo bar' : résultats str
  • r'foo bar' : résultat dit chaîne brute, où échapper des caractères spéciaux n'est pas nécessaire, tout est pris textuellement à mesure que vous tapez
normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

Types de données mutables et immuables

Un objet est appelé mutable s'il peut être modifié. Par exemple, lorsque vous transmettez une liste à une fonction, la liste peut être modifiée:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

Un objet est appelé immuable s'il ne peut être modifié d'aucune façon. Par exemple, les entiers sont immuables, car il est impossible de les modifier:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

Notez que les variables elles-mêmes sont mutables, nous pouvons donc réaffecter la variable x , mais cela ne change pas l’objet que x avait précédemment indiqué. Il ne fait x pointer vers un nouvel objet.

Les types de données dont les instances sont modifiables sont appelés types de données mutables , de même pour les objets et les types de données immuables.

Exemples de types de données immuables:

  • int , long , float , complex
  • str
  • bytes
  • tuple
  • frozenset

Exemples de types de données mutables:

  • bytearray
  • list
  • set
  • dict