Dans les langages de programmation comme Python, un nombre comme 502 et un mot comme "classe", ne sont évidemment pas représentés de la même façon dans l'ordinateur, même si l'unité fondamentale de codage en informatique est le bit qui peut prendre deux valeurs 0 ou 1.

La façon dont une valeur est représentée dans le langage s'appelle son type.

En Python, un entier est de type int et un mot est de type str, qui signifie chaîne de caractères .

De plus, tous les nombres n'appartiennent pas au même type, par exemple les nombres réels sont approchées en machine par un sous-ensemble des décimaux qui est l'ensemble des flottants, de typefloat.

Enfin, dans les structures de test, nous utiliserons des booléens, des valeurs de type bool, qui ne prend que deux valeurs logiques True ou False.

In [8]: a = 502

In [9]: type(a)
Out[9]: int

In [10]: a = 502

In [11]: print(type(a))
<class 'int'>

In [12]: b = "pa"

In [13]: print(type(b))
<class 'str'>

In [14]: a = a + a

In [15]: a
Out[15]: 1004

In [16]: b = b = b

In [17]: b
Out[17]: 'pa'

In [19]: b = b + b

In [20]: print(b)
papa

In [21]: c = 1/3

In [22]: print(type(c))
<class 'float'>

In [23]: a + b
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-22-bd58363a63fc> in <module>()
----> 1 a + b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

In [24]: d = a + c

In [25]: d
Out[25]: 1004.3333333333334

In [26]: print(type(d))
<class 'float'>

In [27]: e = True

In [28]: print(type(e))
<class 'bool'>

In [28]: f = False

In [29]: e and f
Out[29]: False

En Python, les entiers signés (psoitifs et négatifs)) appartiennent au type int, qui n'est limité en taille que par la place disponible en mémoire.

Contrairement aux autres nombres réels, les entiers sont représentés de façon exacte en machine et doivent donc être privilégiés pour les calculs nécessitant une grande précision.

Les opérateurs arithmétiques usuels, présentés dans la page Découverte : console permettent de réaliser des opérations avec des entiers.

Les flottants sont des nombres décimaux dont le développement en base 2 est fini et ils sont de la forme $(-1)^s \times 2^{e} \times 1,\underbrace{010000100101\ldots 1}_{\text{mantisse m sur } 52 \text{ bits}}$ où le bit de signe $s$ est codé sur 1 bit, l'exposant $e$ est codé sur $11$ bits et la mantisse $m$ représentant le développement en base 2 de la partie fractionnaire est codé sur $52$ bits.

In [23]: 3 * 1.4
Out[23]: 4.199999999999999

In [24]: 3 * 1.4 == 4.2
Out[24]: False

In [25]: 0.1 + 0.1 == 0.2
Out[25]: True

In [26]: 0.1 + 0.1 + 0.1 == 0.3
Out[26]: False

In [27]: 3 * 0.1
Out[27]: 0.30000000000000004

Les flottants supportent les mêmes opérateurs arithmétiques usuels que les entiers . De plus ces opérateurs acceptent un opérande de type float et l'autre de type int, le résultat sera alors de type float.

Syntaxe des chaînes de caractères

En Python, les caractères, les mots, les phrases et autres combinaisons des caractère alphabétiques ou de mise en forme (tabulations, espaces) appartiennent au type str, qui signifie chaîne de caractères.

Pour distinguer les chaînes de caractères des mots clefs du langage et des identificateurs de variables, on les délimite par des symboles spéciaux : l'apostrophe ', le guillemet " ou un délimiteur triplé ''' ou """.

In [5]: a = 'une chaine délimitée par des apostrophes'

In [6]: print(type(a))
<class 'str'>

In [7]: print(a)
une chaine délimitée par des apostrophes

In [8]: b = "une chaine délimitée par des guillemets"

In [9]: print(type(b))
<class 'str'>

In [10]: c = 'Des "guillemets" dans une chaine'

In [11]: c
Out[11]: 'Des "guillemets" dans une chaine'

In [12]: d = "L'apostrophe dans une chaine"

In [13]: d
Out[13]: "L'apostrophe dans une chaine"

In [14]: e = 'L\'apostrophe échappée avec un backslash'

In [15]: e
Out[15]: "L'apostrophe échappée avec un backslash"

In [16]: f = """Une chaine 
    ...:        multiligne avec "guillemets"
    ...:        et l'apostrophe
    ...:        """

In [17]: f
Out[17]: 'Une chaine \n       multiligne avec "guillemets"\n       et l\'apostrophe\n       '

Opérateurs sur les chaînes de caractères

• L'opérateur in permet de tester l'appartenance d'un caractère ou d'une sous-chaîne à une chaîne de caractères.

  
  		In [20]: chaine = 'Bonjour'
  		
  		In [21]: 'b' in chaine
  		Out[21]: False
  		
  		In [22]: 'B' in chaine
  		Out[22]: True
  		

• L'opérateur + permet de concaténer deux chaînes de caractères. Attention, l'opérateur - n'est pas défini pour les chaînes de caractères.

  
  		In [28]: chaine = 'Bonjour'
  		
  		In [29]: chaine2 = chaine + ' à tous.'
  		
  		In [30]: print(chaine2)
  		Bonjour à tous.
  		

• La fonction len permet d'obtenir le nombre de caractères contenus dans une chaîne de caractère. Attention les caractères invisibles comme les espaces et les fins de ligne comptent !

  
  		In [31]: chaine2
  		Out[31]: 'Bonjour à tous.'
  		
  		In [32]: print(len(chaine2))
  		15
  		

• La méthode lower permet de convertir tous les caractères en minuscules. La méthode upper permet de convertir tous les caractères en majuscules. Il s'agit de méthodes internes qu'on applique avec la syntaxe chaine.lower() ou chaine.upper().

  
  		In [33]: chaine3 = chaine2.lower()
  		
  		In [34]: chaine3
  		Out[34]: 'bonjour à tous.'
  		
  		In [35]: chaine4 = chaine2.upper()
  		
  		In [36]: chaine4
  		Out[36]: 'BONJOUR À TOUS.'
  		

• Avec la syntaxe chaine[index] permet de lire un caractère dans une chaîne de caractère : les caractères sont indexés de 0 pour le premier à len(chaine) - 1 pour le dernier. Une autre indexation à partir de la fin de la chaîne est disponible : le dernier caractère est index par -1 et le premier par -len(chaine). Si aucun caractère n'est repéré par l'index demandé, on obtient une erreur index out of range.

  
  		In [37]: chaine
  		Out[37]: 'Bonjour'
  		
  		In [38]: chaine[0]
  		Out[38]: 'B'
  		
  		In [39]: chaine[1]
  		Out[39]: 'o'
  		
  		In [40]: chaine[len(chaine) - 1]
  		Out[40]: 'r'
  		
  		In [41]: chaine[-1]
  		Out[41]: 'r'
  		
  		In [42]: chaine[-2]
  		Out[42]: 'u'
  		
  		In [43]: chaine[-len(chaine)]
  		Out[43]: 'B'
  		
  		In [44]: chaine[len(chaine)]
  		---------------------------------------------------------------------------
  		IndexError                                Traceback (most recent call last)
  		<ipython-input-44-e70a16679e7b> in <module>()
  		----> 1 chaine[len(chaine)]
  		
  		IndexError: string index out of range
  		
  		

• Avec la syntaxe chaine[debut:fin:pas] permet de lire une sous-chaîne dans une chaîne de caractère en prenant tous les caractères de l'index debut inclus jusqu'à l'index fin exclu avec un pas fixé, qui peut être négatif. On parle de slicing . Par défaut l'index de début est 0, l'index de fin est len(chaine) et le pas est de 1 et on laisse vide ces paramètres si on utilise les valeurs par défaut.

  
  		In [68]: chaine = 'Bonjour'
  		
  		In [69]: chaine[0:2]
  		Out[69]: 'Bo'
  		
  		In [70]: chaine[-3:-1]
  		Out[70]: 'ou'
  		
  		In [71]: chaine[-3:]
  		Out[71]: 'our'
  		
  		In [72]: chaine[0:2]
  		Out[72]: 'Bo'
  		
  		In [73]: chaine[0:2]
  		Out[73]: 'Bo'
  		
  		In [74]: chaine[-3:]
  		Out[74]: 'our'
  		
  		In [75]: chaine[2:5]
  		Out[75]: 'njo'
  		
  		In [76]: chaine[:]
  		Out[76]: 'Bonjour'
  		
  		In [77]: chaine[::2]
  		Out[77]: 'Bnor'
  
  		In [78]: chaine[1:5:2]
  		Out[78]: 'oj'
  
  		In [79]: chaine[::-1]
  		Out[79]: 'ruojnoB'
  		

		In [63]: chaine = 'papa'
		
		In [64]: chaine[-1]
		Out[64]: 'a'
		
		In [65]: chaine[-1] = 'i'
		---------------------------------------------------------------------------
		TypeError                                 Traceback (most recent call last)
		<ipython-input-65-0fc03e1416a6> in <module>()
		----> 1 chaine[-1] = 'i'
		
		TypeError: 'str' object does not support item assignment
		

Un type avec deux valeurs

Le type booléen, noté bool en Python, ne contient que deux valeurs True ou False

	In [47]: a = True
	
	In [48]: print(type(a))
	<class 'bool'>
	
	In [49]: b = False
	
	In [50]: print(type(b))
	<class 'bool'>
	

Booléens et tests

Les valeurs booléennes sont obtenues comme résultats de tests de comparaison (égalité, inégalité).

		In [51]: 5 == 3
		Out[51]: False
		
		In [52]: a = (5 == 3)
		
		In [53]: type(a)
		Out[53]: bool
		
		In [54]: a
		Out[54]: False
		
		In [55]: b = (5 > 3)
		
		In [56]: type(b)
		Out[56]: bool
		
		In [57]: b
		Out[57]: True
		
		In [58]: c = (5 != 3)
		
		In [59]: c
		Out[59]: True