Bienvenue dans ce tutoriel python, nous allons déterminer si un nombre n est pair ou impair en python.

Un peu de mathématique : N est-il pair ou impair ?

En revenons à nos anciens cours de mathématique, on  trouve cette définition:

Un nombre N est pair s’il existe un nombre a tel que N=2A

Autrement, un nombre N est impair s’il existe un nombre a tel que N= 2A +1

De plus, nous vous dévoilons une autre définition en utilisant la notion du modulo:

Le concept de “modulo” peut sembler complexe, mais il est nous l’utilisons fréquemment dans la vie quotidienne, en particulier lors de comptages cycliques. En des termes simples, le modulo est représenté mathématiquement par le symbole “%”.

def est_pair_ou_impair(nombre):
if nombre % 2 == 0:
return f”{nombre} est un nombre pair.”
else:
return f”{nombre} est un nombre impair.”

Exemples d’utilisation :

print(est_pair_ou_impair(4)) # Résultat : “4 est un nombre pair.”
print(est_pair_ou_impair(7)) # Résultat : “7 est un nombre impair.”

Le modulo en mathématiques et python

Lorsque nous disons que a mod n est congru à b mod n , nous disons que a et b ont le même reste lorsqu’ils sont divisés par n. Si on nous demande de trouver c mod n , nous ne trouvons le reste que lorsque nous divisons c par n .  

number % 2

Comme vous pouvez le voir, nous utilisons l’opérateur modulo %, qui renvoie le reste de la division du nombre par 2.

En Python, nous pouvons utiliser l’opérateur % (Module Operator) pour trouver le reste d’un nombre.

Par conséquent, logiquement, nous pouvons écrire du code pour trouver le reste lorsqu’un nombre donné est divisé par 2. Si le résultat n’est pas 0, le nombre est impair. Si c’est 0, on le considère comme pair.

nombre = 2
si nombre % 2 == 0 :
     print("le nombre pair")
else:
     print("le nombre est impair")

Bien qu’il s’agisse d’une expression simple, nous pouvons créer une fonction pour mieux séparer et organiser le code du programme. Dans ce cas, nous pouvons simplement le faire comme suit :

def is_odd(num: int) -> bool:
    return num % 2 == 0

 On commence par un entier positif. On l’évalue, si le nombre est pair on le divise par 2. S’il est impair on le multiplie par 3 et on ajoute 1. On évalue le résultat encore et encore, on applique les opérations correspondantes.

Au final, la séquence de nombres se termine par 4 , 2, 1

Mais il n’a pas été démontré que cela se produit pour tous les entiers positifs, c’est donc une conjecture.

Voyons un exemple très simple :

number = int(input("Entrez un entier positif : "))
if number > 0:
     while number != 1:
         if number % 2:
             number = number * 3 + 1
         else:
             number //= 2
         print(number)
else:
     print("le numéro que vous avez entré est invalide")

Exemple de code python

number = 0
num_pairs = 0
resutls = 1
 
while num_pairs < 100:
   number += 1
 
   # Simular un if con while


   while number%2 == 0:
       num_pairs += 1
       resutls *= number
       break
 
print('Le produit des 100 premiers nombres pairs est', resutls )

 

Le Modulo en mathématiques et Python

Comprendre le Modulo

Le modulo, noté a mod n, signifie que “a” et “b” laissent le même reste lorsqu’ils sont divisés par “n”. Lorsque vous cherchez à trouver c mod n, vous cherchez simplement le reste de la division de “c” par “n”.

Utilisation du Modulo en Python

En Python, nous utilisons l’opérateur modulo % pour trouver le reste d’une division. Cet opérateur est essentiel pour déterminer si un nombre est pair ou impair.

Vérification de la parité

Pour vérifier si un nombre est pair en Python, nous utilisons la formule suivante : nombre % 2. Si le résultat est égal à 0, le nombre est pair. Sinon, il est impair.

Voici comment cela peut être fait en Python :

nombre = 2
if nombre % 2 == 0:
    print("Le nombre est pair.")
else:
    print("Le nombre est impair.")

Utilisation d’une Fonction

Pour organiser et structurer votre code, il est recommandé d’utiliser une fonction. Voici une fonction simple qui détermine si un nombre est pair :

def is_pair(num: int) -> bool:
    return num % 2 == 0

La Conjecture de Collatz

La conjecture de Collatz est un problème mathématique qui commence par un entier positif. Si le nombre est pair, on le divise par 2, sinon, on le multiplie par 3 et on ajoute 1. On répète ce processus, et on finit généralement par atteindre le nombre 1.

Un exemple de code Python pour illustrer cette conjecture :

number = int(input("Entrez un entier positif : "))

if number > 0:
    while number != 1:
        if number % 2:
            number = number * 3 + 1
        else:
            number //= 2
        print(number)
else:
    print("Le numéro que vous avez entré est invalide.")

Calcul du produit des nombres pairs

Enfin, voici un exemple de code Python pour calculer le produit des 100 premiers nombres pairs :

number = 0
num_pairs = 0
results = 1

while num_pairs < 100:
    number += 1

    # Simuler une condition "if" avec une boucle "while"
    while number % 2 == 0:
        num_pairs += 1
        results *= number
        break

print("Le produit des 100 premiers nombres pairs est", results)

Le modulo est un concept mathématique puissant qui trouve une application pratique dans la programmation, notamment pour déterminer la parité des nombres. La conjecture de Collatz est également un problème mathématique fascinant, bien que non résolu, qui peut être exploré avec des scripts Python.