Les nombres entiers ne sont pas les seuls nombres, comme on le verra dans les chapitres suivants. Alors comment fait "Python" pour savoir qu'un nombre est entier ?
Comme le langage est faiblement typé, il doit le deviner.
Le critère est simple : Pour qu'un nombre soit entier, il ne doit pas avoir de virgule (représentée dans "Python" par un point décimal).
=Les nombres entiers dans Python=
Ainsi, si on entre
a=3
print(type(a))
b=3.14
print(type(b))
c=int(b)
print(c)
on constate que "Python" sait que "a" est entier, que "b" ne l'est pas, et que "c" peut être entier bien qu'obtenu à partir de "b" (qui est réel).
Certains calculs devant donner un résultat entier ne le font pas toujours en "Python". Par exemple, alors que formula_1, "Python" considère ce nombre comme un réel (non entier)!
from math import *
a=sqrt(100)
print(a.is_integer())
=Opérations=
Addition, soustraction et multiplication.
Les trois premières opérations se notent avec les symboles "+", "-" et "*" comme dans la plupart des langages de programmation. La somme, la différence et le produit de deux entiers (ou plus) sont des entiers (relatifs):
a=5
b=-8
print(a+b)
print(a-b)
print(a*b)
La tortue.
On peut représenter l'addition par des mouvements successifs de la tortue. Pour cela il faut bien entendu importer le module "turtle". Après ça pour additionner 55 et 34, on peut faire avancer la tortue successivement de 55 pixels puis 34 pixels, et regarder où elle est:
from turtle import *
forward(55)
forward(34)
print(position())
Pour soustraire le deuxième nombre au lieu de l'additionner, il suffit de faire reculer la tortue au lieu de la faire avancer; et ça marche même avec des nombres négatifs:
from turtle import *
forward(55)
backward(34)
print(position())
Divisions.
Il y a deux sortes de divisions d'entiers en "Python": Le quotient euclidien, qui est un entier, et le quotient exact, qui est une fraction (pour "Python", un réel):
Quotients.
Dans les anciennes versions de "Python", le script suivant 
a=3
b=2
print(a/b)
affichait 1 au lieu de 1.5, parce que pour "Python", comme "a" et "b" sont entiers, leur quotient était logiquement euclidien. Ceci a changé, maintenant le script ci-dessus produit bien 1.5; mais du coup, si par hasard on voulait quand même calculer une division euclidienne avec "Python"? Et bien dans ce cas il faudrait dédoubler le "slash" qui code la division:
a=3
b=2
print(a//b)
Ce peut être utile parce que même en divisant 4 par 2, le résultat est un réel non entier, alors que la division euclidienne produit bien le nombre entier 2.
Reste euclidien.
Le reste de la division euclidienne de 13 par 8 est 5. Pour le calculer, on utilise l'opérateur infixé "%":
a=13
b=8
print(a%b)
Cette opération permet de travailler sur les congruences. Remarque: Si b=0, on a le même message d'erreur que lorsqu'on divise par 0.
Divisibilité.
Deux entiers quelconques ont un pgcd. En "Python", on l'obtient avec "gcd". Mais cette fonction ne se trouve pas par défaut dans "Python"; elle se trouve dans le fichier "fractions.py", dont on peut importer la totalité des objets par "from fractions import *":
a=13572468
b=12345678
print(gcd(a,b))
Comme "Python" est libre, on peut consulter le source de "fractions.py", où on trouve ceci:
def gcd(a, b):
 while b:
 a, b = b, a%b
 return a
On reconnaît (d'autant plus aisément que le langage est concis) l'algorithme d'Euclide.
Puissances.
Beaucoup de langages de programmation utilisent le chapeau pour représenter les puissances. Pas "Python" pour qui le chapeau est déjà pris par une autre opération (le "ou exclusif" bit à bit). Alors c'est l'astérisque de la multiplication qui est utilisé pour les puissances, mais en le dédoublant:
a=4
b=2
print(a**b)
print(b**a)
Remarque: Si l'exposant est négatif ou non entier, le résultat est un réel. En particulier, les deux opérations ci-dessous ont le même effet:
print(100**0.5)
from math import *
print(sqrt(100))
Priorités opératoires.
En "Python" comme en algèbre, on effectue dans l'ordre
Ainsi 
print(2+3*5)
affiche 17 et non 25: Les opérations ne sont pas effectuées de gauche à droite, mais en suivant les priorités opératoires.
=Itérateurs=
Un itérateur de "Python" est une liste d'entiers. Par exemple, la liste 10, 13, 16, 19, 22, 25 (allant de 3 en 3, de 10 jusqu'à 25) s'appelle "range(10,26,3)". On peut abréger les itérateurs en omettant le troisième argument (par défaut 1) voire le premier (par défaut 0). Ainsi "range(5)" contient les entiers 0, 1, 2, 3 et 4 (0 compris, 5 non compris, ce sont donc bien les 5 premiers entiers naturels).
Lorsqu'on lance un dé, le résultat obtenu peut être 1, 2, 3, 4, 5 ou 6. Il peut donc être décrit par "range(1,7)". Pour vérifier que l'évènement "le dé tombe sur 3" est possible alors que l'évènement "le dé tombe sur 7" est impossible, on peut faire 
dice=range(1,7)
print(3 in dice)
print(7 in dice)

Mathématiques avec Python et Ruby/Fractions en Python