LangageTypesPredefinis

[wiki: Types prédéfinis] [#license ©]

PageOutline

Vue d’ensemble

  • Nombres : int, float, complex.
  • Collections
  • Séquences non modifiables
  • str : 'hello' ou "hello"
  • tuple : 'a', 'b', 'c'
  • Séquences modifiables
  • list : [ 'a', 'b', 'c' ]
  • Associations modifiables
  • dict : { 'a' : 'val', 3 : 'x', 'key' : 124 }
  • set : { 'a', 3, 'key' }
  • Associations non modifiables
  • frozenset : { 'a', 3, 'key' }
  • Divers
  • bool
  • !NoneType : None
  • type

Entiers

  • int
  • Peut prendre des valeurs illimitées, et se charge d’optimiser la représentation interne des entiers.
  • La fonction int() permet de transformer explicitement un texte en nombre. En cas d’impossibilité, l’exception !ValueError est émise.
  • La fonction str() transforme un entier en chaîne de caractères.

Réels et complexes

  • float
  • équivalent d’un double du C.
  • ces nombres s’écrivent avec un « . » et/ou un exposant « e » ou « E » : 1.23, 3.14e-10, 4E210, 4.0e+210
  • complex
  • équivalent de deux floats
  • s’écrit avec un « j » ou « J » : 3+4j
  • la fonction str() transforme un float ou un complex en chaîne de caractères. les fonctions float() et complex() transforment une chaîne de caractère en float ou complex.

Opérations numériques

  • Un opérateur puissance :
**
  • Quelques opérateurs spécifiques aux entiers :
& | ^ ~ << >>
  • Deux formes de division
  • / : division classique qui retourne un nombre flottant, quel que soit ses arguments.
  • // : quotient entier qui retourne un flottant en cas d’arguments flottants, un entier en cas d’arguments entiers.
>>> 2/3
0.6666…
>>> 2//3
0
>>> 2./3.
0.6666…
>>> 2.//3.
0.0
>>> 6/2
3.0
>>> 6//2
3
>>> 6./2.
3.0
>>> 6.//2.
3.0

Séquences (str, tuple, list)

  • Nombre d’éléments par len(<sequence>)
  • Accès aux éléments par [<indice>]
  • Les indices négatifs permettent de parcourir les éléments en partant de la fin
  • Le premier élément a l’indice 0 ou -len()
  • Le dernier élément a l’indice len()-1 ou -1
  • On peut extraire une tranche en donnant un indice de départ, un indice de fin (exclus), et éventuellement un pas, séparé par des « : »
  • Les mauvais indices induisent une exception IndexError
>>> li = 1, 2, 3, 4
>>> len(li)
4
>>> li[0]
1
>>> li[-1]
4
>>> li[0:2]
(1, 2)
>>> li[:2]
(1, 2)
>>> li[1:]
(2, 3, 4)
>>> li[::2]
(1, 3)
>>> li[3:0:-2]
(4,2)

Modification des listes

  • Modifier un élément ou une tranche
  • l[i] = x
  • l[i:j:k] = t
  • Supprimer un éléments ou une tranche
  • del l[i]
  • del l[i:j:k]
  • Ajouter un élément ou une séquence
  • l.append(x)
  • l.insert(i,x)
  • l.extend(t)
  • Diverses méthodes : reverse(), sort()…
>>> li = [ 1, 2, 3, 4 ]
>>> li[0:3:2] = [ -1,-2]
>>> li
[ -1, 2, -2, 4 ]
>>> del li[:2]
>>> li
[ -2, 4 ]
>>> li.insert(1,None)
>>> li
[ -2, None, 4 ]
>>> li.extend( [ 1, 2 ] )
>>> li
[ -2, None, 4, 1, 2 ]
>>> li.sort()
>>> li.reverse()
>>> li
[ 4, 2, 1, -2, None ]

Tuples

  • 'a', 'b', 'c' ou ('a', 'b', 'c') (ce sont les virgules qui déclenchent la création du tuple, pas les parenthèses).
  • Non modifiables et optimisés en conséquence.
  • Souvent utilisés implicitement, notamment dans les instructions qui reposent sur un ensemble de valeurs séparées par des virgules.
  • ATTENTION: les parenthèses sont aussi utilisées pour grouper des éléments dans une expression. Pour éviter certaines ambiguités, quand un tuple ne contient qu’un seul élément, on laisse une virgule avant la parenthèse fermante. Le cas le plus dangereux est celui d’un tuple de chaines de caractères, car si il y a une seul chaine et qu’on oublie la virgule, la chaine est interprétée comme une séquence de n caractères.
>>> l = ['t','o','t','o']
>>> tpl = tuple(l)
>>> tpl[0]
't'
>>> s = 'toto'
>>> tpl = tuple(s)
>>> tpl[0]
't'
>>> tpl = ( 'toto', 'tutu' )
>>> tpl[0]
'toto'
>>> tpl = 'toto', 'tutu'
>>> tpl[0]
'toto'
>>> tpl = ('toto')
>>> tpl[0]
't'
>>> tpl = ('toto',)
>>> tpl[0]
'toto'
>>> tpl = 'toto',
>>> tpl[0]
'toto'

Chaines de caractères

Type str. Les caractères sont unicode (par défaut en UTF8).

Définition d’une chaîne :

  • Quatres sortes de littéraux (ordinaire=unicode, brute, multi-ligne, octets=ascii)
  • Pas de différence entre ‘ et « 
  • Utilisation habituelle du \ pour éliminer le comportement spécial d’une fin de ligne, d’une quote ou du backslash lui-même.
>>> s1 = "chaine unicode"
>>> s2 = r"chaine brute"
>>> s3 = """
chaine
multi-ligne
"""
>>> s4 = b"chaine d'octets"

Opérateurs

  • + et *
  • Accès aux lettres par [], mais interdiction de la modifier : toutes les méthodes ou fonctions applicables aux chaines de caractères retournent une copie modifiée de l’originale.

Quelques fonctions et méthodes

  • len() : renvoie la taille d’une chaîne,
  • str.find() : recherche une sous-chaîne dans la chaîne,
  • str.rstrip() : enlève les espaces de fin,
  • str.replace() : remplace une chaîne par une autre,
  • str.split() : découpe une chaîne en liste,
  • str.join() : concatène une liste en chaîne,
  • str.isdigit() : renvoie True si la chaîne contient que des nombres, False sinon.
  • str.format() : formatage de données.

L’utilisation de méthodes, notamment sur les littéraux, peut surprendre au premier abord :

>>> elements = 'A/B/C'.split('/')
>>> print('|'.join(elements))
A|B|C

On notera également que l’ancien opérateur de formattage %, sujet à de nombreux problèmes, n’est plus recommandé. On lui préfèrera la méthode str.format(), beaucoup plus complète, tout en restant familière dans les cas simples :

>>>'{0:03.2f} {2:d} {1:f}'.format(1/3,2/3,1)
'0.33 1 0.666667'
#!comment
Rappelons que Python est un langage au typage fort : il ne considère donc pas '1' comme un nombre
On transforme une chaîne en nombre avec les fonctions int(), long(), float(), complex().

On peut donner plusieurs chaines à la suite, séparées par des espaces, et l’interpréteur procédera à une concaténation automatique. A condition de mettre des parenthèses, on peut même le faire sur plusieurs lignes :

>>> s = '1' '2' '3'
>>> s
'123'
>>> s = (
... '1'
... '2'
... '3'
... )
>>> s
'123'

ATTENTION : cette propriété n’est pas très recommandable, sauf cas très particuliers, mais il est utile de la connaître pour comprendre certains dysfonctionnements. Par exemple, si on insère des virgules par erreur ou si on en oublie :

>>> s = (
... '1',
... '2'
... '3'
... )
>>> s
('1', '23')

Dictionnaires

  • On peut utiliser comme clé, entre [], tout objet non modifiable.
  • Lorsqu’on modifie un élément dont la clé n’existe pas, elle est crée.
  • Lorsqu’on lit un élément dont la clé n’existe pas, une exception !NameError est levée.
  • On peut mélanger tous les types de clés et de valeurs dans un même dictionnaire.
>>> d = { 8: 'val', 3.2: 'x', 'key': 124 }
>>> d[3.2]
'x'
>>> d.keys()
[ 8, 3.2, 'key' ]
>>> d.values()
[ 'val', 'x', 124 ]
>>> d[(1,)] = None
>>> del d[3.2]
>>> d
{ 8: 'val', 'key': 124, (1,): None }
>>> d2 = d.copy()
>>> d.clear()
>>> d2
{ 8: 'val', 'key': 124, (1,): None }
>>> d
{}
#!comment
les dictionnaires ne sont pas des ensembles ordonnés, c’est à dire que l’on ne peut prédire à quel endroit s’ajoutera une paire
pas de slices ?

Quelques autres

  • set et frozenset : des ensembles, dotés des opérateurs |&-^ et des méthodes issubset() et issuperset().
  • bool : prend la valeur True ou False.
  • !NoneType : le type de None.
  • type : le type de tous les objets types.
>>> type(True)
<class 'bool'>



>>> type(None)
<class 'NoneType'>





>>> type(type(True))
<class 'type'>





>>> type(type(None))
<class 'type'>

#!comment
Autres types :
fonctions
modules

Exercices

Essayez et modifiez les exemples ci_dessus, soit avec le Online Python Tutor, soit avec l’interpréteur IPython fourni avec Anaconda. »

Références

© David Chamont, Laboratoire Leprince-Ringuet (LLR) / IN2P3 / CNRS, Ecole polytechnique / Université Paris-Saclaybr
© Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution – Partage dans les Mêmes Conditions 4.0 International [=#license]

Attachments