Python: Types de bases

From Wiki Cours
Jump to: navigation, search

<--Sommaire

Constante et variable

  • une constante désigne une valeur connue non modifiable possédant un certain type.
  • une variable est l'association d'un nom associé à un espace réservé en mémoire (une adresse) et un contenu qui est typé. La variable a le type du contenu.
  • en Python, une variable peut changer de type à loisir
  • certains types peuvent être convertis les uns en les autres, au prix parfois d'une perte d'information.
  • un opérateur est une fonction simple, écrits souvent selon la symbolisation mathématique usuelle, qui prend typiquement un ('unaire') ou deux ('binaire') arguments (les opérandes) et renvoie un résultat
  • l'affectation d'un contenu (constante, résultat d'une fonction ou d'une expression) à une variable se fait à l'aide du symbole '='.
  • une expression est la combinaison de constantes, variables, fonction, opérateurs... sur une même ligne

a = 10 # on affecte la constante entière 10 à la variable 'a'

Il est possible en python de faire des affectations multiples sur la même ligne pour gagner en lisibilité et en concision

a, b, s = 10, 9.3, 'nom'

Le mot-clé del permet de rompre l'affectation et libère le nom de la variable du contenu qui n'est pas pour autant supprimé

del a # ou del(a) qui fonctionne aussi
print(a)

La fonction type() permet d'afficher le type d'une variable

type(a), type(b), type(c)

On peut obtenir l'adresse en mémoire vive d'une variable avec la fonction id()

id(a), id(b), id(c)

Entiers

En Python 2.7

Les entiers ont deux types int en 32bits et long en 64bits. Le passage en long se fait automatiquement si besoin.

a = 2147483647  # 2**31 - 1
type(a)
a += 1
type(a)
a = 10000000000L  # le L permet de dire que la constante est un long
a = 0xABCEF       # écriture en hexadécimal après '0x'

À noter que les utilisateurs ont souvent des bugs à cause du fait que la division par défaut (opérateur '/') correspond à la division entière pour deux entiers (équivalent donc à l'opérateur '//').

3/4  # donne 0

Le problème est résolu par conversion vers les floats (en ajoutant un point pour les constantes et float() pour les variables), ou bien en important la bibliothèque future

3./4.  # donne 0.75
from future import division
3/4    # donne 0.75

En Python 3.x

D'une part, il n'existe plus de distinction entre les types int et long, tout est contenu dans le type int, d'autre part, les limites associées à la longueur des mots (32bits ou 64bits) disparaissent car l'implémentation augmente la mémoire utilisée pour représenter l'entier et éviter les problèmes d'overflow.

a = 10**306 # ne pose pas de problème d'overflow
a**2        # là aussi, alors que pour le type float, il y en a un
type(a)
a = 0b10011001   # écriture en binaire après '0b' 
a = 0xABCEF      # écriture en hexadécimal après '0x'
a = int("120", base=3) # écriture en base quelconque (ici en base trois, ce qui donne 15)

À noter que la division entre deux entiers renvoie maintenant un réel

3/4  # donne 0.75

On notera également que le type 'float' en Python 3 gère les nombres rationnels de façon exacte.

Réels

Les nombres réels sont définis littéralement par l'usage du point qui symbolise la virgule:

a = 1.0 # on affecte la constante entière 10 à la variable 'a'

La notation scientifique usuelle permet de simplifier l'expression des puissances de 10:

print( 3.2*10**3 == 3.2e3 )

La conversion en réel se fait par la fonction float qui permet de les définir également:

a = 2
type(a)
a = float(2)
type(a)

La bibliothèque math fournit de nombreuses fonctions mathématiques pour les réels.

Complexes

Les nombres complexes peuvent être créés et manipulés aisément dans python. Ils ont la forme 'a + bj' où 'a' et 'b' sont les parties réelles et imaginaires. On peut les créer aussi avec la fonction 'complex(a,b)'.

c = complex(1,2)
d = 1 + 2j
print(c - d)
print( (1+1j)**2 / (1j) )
print(c.real, c.imag)

La bibliothèque cmath fournit de nombreuses fonctions mathématiques pour les complexes.

Booléens

Un booléen a deux états possibles False ou True, associés 0 pour le premier et 1 pour le second en binaire. Il correspond au type bool en Python. C'est le type attendu par un test de condition et le résultat des opérateurs de comparaison.

test = True
print(test)
bool(0)
bool(13928)

Les types de bases possède un '0' ou vide qui se convertit en False en booléen

bool(0)  # int
bool(0.) # float
bool("") # str
bool([]) # list
bool({}) # dict
bool(()) # tuple

Opérateurs standards

Ils s'appliquent ou pas en fonction du type

symbole effet exemple
+ addition 6+4 == 10
- soustraction 6-4 == 2
* multiplication 6*4 == 24
/ division 6/4 == 1.5
** élévation à la puissance 6**4 == 1296
// division entière 6//4 == 1
 % reste de la division entière 6%4 == 2

ainsi que tous les opérateurs unaires qui prennent la variable et lui ré-affectent le résultat: += , -= , *= , /= , **= , //= , %=

Les règles de précédence sont les mêmes qu'en mathématiques : dans l'ordre d'importance

  1. parenthèses
  2. exposant
  3. division et multiplication
  4. addition et soustraction

Et, pour les opérations de même priorité, application de gauche à droite.

Chaînes de caractères

On peut les créer à partir de constantes entourées de guillemets ou entre apostrophes ou par l'utilisation de la fonction str

mot = "Bonjour!"
mot = 'Bonjour!'  # même résultat
nombre = 102983
vide = "" # chaîne de caractère vide ou pas de caractère
aff = str(nombre)
print(nombre, aff)

On peut additionner (on dit concaténer pour les chaînes de caractères) et multiplier des strings, mais pas les soustraire ou les diviser

mot = "et "
mot *= 3
mot += "alors..."
print(mot)

En fait, une 'string' fonction à peu près comme une liste dans laquelle chaque caractère est un élément. On peut donc accéder à ses éléments par les méthodes de slicing et autres.

mot = "Bonjour!"
print(mot[-1], mot[3:5], 'B' in mot)

Cependant, on ne peut pas modifier un caractère d'une chaîne de caractère en l'adressant. Il faut en créer une nouvelle.