Python: Types de bases
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
à l'intérieur des fonctions ou des classes, les variables sont a priori définies localement à l'intérieur du bloc:
def f():
a = 10
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 a priori y accéder. 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
a = 20
f()
renvoie une erreur car au moment du 'print', Python voit un conflit entre la variable locale et celle du niveau au-dessus. Par contre, la syntaxe
a = 10
def f():
a = 20
print a
f()
print a
fonctionne car Python suppose que l'on affiche la variable locale qui a été affectée. En revanche, la variable 'a=10' demeure inchangée. Pour que la fonction puisse modifier la variable 'a' du niveau supérieur au moment de l'affectation, il faut utiliser le mot-clé global. Ainsi,
a = 10
def f():
global a
a = 20
print a
f()
print a
fonctionne et a bien modifié la valeur de 'a' au niveau supérieur.
Il est préférable dans tous les cas d'avoir des noms de variables trop globaux, sauf pour de petits code, mais à é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