Python: Types de bases

<--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'

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)

Portée des variables

Le bloc principal s'appelle le bloc global, les variables qui y sont définies sont appelées 'variables globales' et visibles par la fonction globals(). Dans les bloc secondaires, les variables déclarées sont locales et visibles en utilisant locals().

À l'intérieur des fonctions ou des classes, les variables sont définies localement à l'intérieur du bloc. Elles sont créées et détruites à l'appel de la fonction et ne sont pas visibles à l'extérieur. Par exemple:

def f():
    a = 10
    print locals()
f()
print a

renvoie une erreur car 'a' n'est pas définie dans le bloc où il y a 'print'. Par contre, la structure

a = 10
def f():
    print a
f()

fonctionne car 'a' est définie dans le bloc supérieur et f() peut y accéder. Dans ce cas, on dit que 'a' est une variable globale. C'est le cas des variables définies à l'extérieur des fonctions. Les fonctions peuvent accéder à leur contenu mais, sauf mention du contraire (voir ci-après), elles ne peuvent les modifier.

On peut avoir des variables globales et locales avec le même nom. Dans ce cas, c'est la variable locale qui est utilisée en priorité si elle existe.

a = 10 # variable globale
def f():
    a = 20 # variable locale
    print a
f()
print a

La variable globale demeure inchangée.

Cependant, il peut y avoir un conflit si l'on souhaite définir localement une variable s'appelant également 'a'. Ainsi,

a = 10
def f():
    print a  # voit qu'une variable locale existe ainsi qu'une globale et veut utiliser la locale
    a = 20   # à cause des règles de priorité
f()

renvoie une erreur car au moment du 'print' car Python cherche à utiliser la variable locale (il voit qu'elle a été définie dans le corps de la fonction) mais elle n'a pas encore été affectée. Ce code est erroné sémantiquement.

Pour que la fonction puisse modifier la variable globale 'a' il faut utiliser le mot-clé global qui signale que la variable 'a' à utiliser dans la fonction est la variable globale et non une variable locale à créer. Ainsi,

a = 10
def f():
    global a
    a = 20
    print a
f()
print a

a bien modifié la valeur de la variable globale 'a'.

Il est préférable dans tous les cas de minimiser le nombre de variables globales et par conséquent l'utilisation du mot-clé global. Cependant, cela peut résoudre simplement des problèmes. Il faut les éviter pour des bibliothèques et des modules.

Entiers

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'

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 = (2 == 1)
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 (entière ou réelle en fonction du type de donnée)	6/4 == 1 ou bien 6./4 == 1.5
**	élévation à la puissance	12**2 == 144
//	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: += , -= , *= , /= , **= , //= , %=

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.