Les opérateurs de comparaison en Python et l'utilisation de l'opérateur modulo(%) pour vérifier si un nombre est pair ou impair

Introduction

In this article, we are going to see Python boolean operators and the modulo operator (%) so we can use them to perform calculations and arithmetic.

As well as the Stack data structure. In order to keep up with this course, you should have an idea about Python 3, some necessary concepts about data structures like List and OOP(Object Oriented Programming) .

Les opérateurs booléens en Python:

Comme tout langage de programmation orienté objet, Python utilise des opérateurs pour comparer des valeurs. Ils sont souvent appelés des opérateurs booléens, car le mot Boolean indique que le résultat de l'utilisation de l'opérateur est une valeur booléenne: true ou false. Ce qui suit est une liste de valeurs Booléennes qu'on peut utiliser en Python pour évaluer des expressions, écrire des fonctions et comparer des valeurs, la liste est comme suivant:

• == indique que vous êtes entrain de vérifier si deux valeurs sont égales.

• != indique que vous êtes entrain de vérifier si deux valeurs ne sont pas égales, par exemple:

  6 != 12
  

  la réponse sera la valeur booléenne : true.

• > indique que vous êtes entrain de comparer deux valeurs pour voir si la première valeur est plus grande que la deuxième, si on prend l'exemple précédent et on remplace != par > la réponse sera la valeur booléenne false, car 6 est inférieur à 12.

• <= indique que vous êtes entrain de comparer deux valeurs pour voir si la première valeur est inférieure ou égale à la deuxième, par exemple:

  13 <= 13
  

  la réponse sera la valeur booléenne : true

• >= indique que vous êtes entrain de comparer deux valeurs pour voir si la première valeur est supérieure ou égale à la deuxième, si on garde l'exemple précédent et qu'on change l'opérateur par <=, la réponse ne changera pas.

L'opérateur modulo (%)

Pour vérifier en Python qu'un nombre est premier ou non, on a besoin d'utiliser l'opérateur modulo(%). Quand on place cet opérateur entre deux nombres, cela calcule le reste de la division du premier nombre sur le deuxième. Si les deux nombres sont égaux ou que le deuxième soit l'un des diviseurs du premier, le résultat sera naturellement 0, sinon vous aurez un résultat différent. Par exemple:

8 % 4
4 % 3

Dans le premier exemple, 4 est un diviseur de 8, le résultat est 0. Dans le deuxième exemple, la réponse sera le reste de la division de 4 sur 3 (3*1+ 1(reste)) qui est 1.

Cet opérateur est utilisé pour vérifier si un nombre est pair ou impair, si le résultat de ce nombre modulo 2 est 0 alors le nombre est pair sinon, le nombre est impair.

Exemple

if (num % 2 == 0): #le nombre est pair -- insérer le code à exécuter
else: #le nombre est impair -- insérer le code à exécuter

Ce fragment de code peut être utilisé pour exécuter des fonctions en se basant sur le cas d'un nombre pair ou impair.

Les piles

Introduction

Quand vous entendez le mot pile, la première chose qui vous vient à l'esprit est une pile de livres, on peut se servir de cette analogie pour expliquer la concept des piles:

1. Il y'a un livre au sommet de la pile, s'il n'existe qu'un seul livre, celui-ci va être considéré comme étant le plus haut livre dans la pile)
2. Vous ne pouvez pas accéder aux autres livres qu'en retirant le livre qui se trouve au sommet de la pile.
3. Une fois, vous retirez tous les livres du sommet un par un, il n'y aura plus de livres, par conséquent, vous ne pouvez pas retirez des livres car il n'existent plus.

Projetons ce qu'on vient d'expliquer sur les piles comme étant des structures de données:

1. Gardez une trace de l'élément sommet car cela vous permettra d'avoir des informations sur le nombre des éléments dans la pile et si la pile est pleine ou vide (si la pile est vide, celle-ci est initialisée à zéro ou à un nombre négatif)
2. Le dernier élément qui entre la pile sera toujours le premier à la quitter(Last In First Out - LIFO)
3. Si tous les éléments sont retirés, la pile serait vide et si vous tentez à retirer des éléments d'une pile vide, un message d'avertissement serait lancé.
4. Si la pile atteint son maximum et que vous tentez de lui ajouter des éléments, un message d'avertissement serait lancé.

Notes:

1. L'entrée et la sortie des éléments n'est possible que du sommet(top) de la pile.
2. Empiler - ajouter des éléments à la pile.
3. Dépiler - retirer des éléments de la pile.
4. L'accès aléatoire à la pile n'est pas permis- Vous ne pouvez pas ajouter ou enlever un élément du milieu de la pile.

Comment implémenter une pile?

Implémenter une pile en utilisant une liste:

On va définir une classe pile et son va lui ajouter des méthodes pour pouvoir performer les opérations suivantes:

1. Empiler des éléments dans la pile.
2. Dépiler des éléments de la pile et lancer un message d'avertissement si la pile est vide.
3. Avoir la taille de la pile.
4. Afficher tous les éléments de la pile.

class pile:
  
  #le constructeur crée une liste
  def init_pile(self):
    self.pile = list()
  #Ajouter des elements a la pile
    def empiler(self,info):
        #Verifier si on a pas entrer une valeur deux fois
        if info not in self.pile:
            self.pile.append(info)
            return True
        return False

    #Retirer le dernier element de la pile
    def depiler(self):
        if len(self.pile)<=0:
            return ("Pile Vide!")
        return self.pile.depiler()
        
    #Avoir la taille de la pile
    def size(self):
        return len(self.pile)

maPile = pile()
print(maPile.empiler(5)) #ecrire True
print(maPile.empiler(6)) #ecrire True
print(maPile.empiler(9)) #ecrire True
print(mmaPile.empiler(5)) #ecrire False vu que 5 est déjà empilé
print(maPile.empiler(3)) #ecrire True
print(maPile.size())  #ecrire 4 
print(maPile.depiler())   #ecrire 3
print(maPile.depiler())   #ecrire 9
print(maPile.depiler())   #ecrire 6
print(maPile.depiler())   #ecrire 5
print(maPile.size())  #ecrire 0
print(maPile.depiler())   #ecrire Pile Vide!

Remarque:

On n' a pas à s'inquiéter à propos de la taille de la pile car celle-ci est représentée par une liste que sa taille peut changer dynamiquement.

Implémenter une pile en utilisant un tableau

Si vous voulez implémenter une pile en utilisant un tableau, il faut utiliser un pointeur qui pointe sur le sommet de la pile qui va vérifier le statut de la pile.

Algorithme

1. Déclarer une liste et un entier MaxSize indiquant la taille maximale de la pile.
2. Le sommet est initialisé à 0.
3. Opération d'empiler:
   1. vérifier si la position du sommet est inférieur à MaxSize de la pile.
      1. Si oui, ajouter un élément à la pile et incrémenter le sommet de 1.
      2. Sinon, afficher le message de pile pleine.
4. Opération de dépiler:
   1. vérifier si la position du sommet est supérieur à 0:
      1. Si oui, dépiler le dernier élément de la liste et décrémenter le sommet de 1
      2. Sinon, afficher le message de pile vide
5. opération Size:
   1. la valeur du pointeur sur sommet est la taille de la pile.

Programme

class pile:
    
    #Constructeur 
    def init_pile(self):
        self.pile = list()
        self.maxSize = 8
        self.sommet = 0
    
    #ajouter des éléments à la pile
    def empiler(self,info):
        if self.sommet>=self.maxSize:
            return ("Pile Pleine!")
        self.pile.append(info)
        self.sommet += 1
        return True
        
    #retirer des éléments de la pile
    def depiler(self):
        if self.sommet<=0:
            return ("Pile Vide!")
        elem = self.pile.depiler()
        self.sommet-= 1
        return elem
        
    #taille de la pile
    def size(self):
        return self.sommet

p= pile()
print(p.empiler(1))#écrire True
print(p.empiler(2))#écrire True
print(p.empiler(3))#écrire True
print(p.empiler(4))#écrire True
print(p.empiler(5))#écrire True
print(p.empiler(6))#écrire True
print(p.empiler(7))#écrire True
print(p.empiler(8))#écrire True
print(p.empiler(9))#écrire Pile Pleine!
print(p.size())#écrire 8        
print(p.depiler())#écrire 8
print(p.depiler())#écrire 7
print(p.depiler())#écrire6
print(p.depiler())#écrire 5
print(p.depiler())#écrire 4
print(p.depiler())#écrire 3
print(p.depiler())#écrire 2
print(p.depiler())#écrire 1
print(p.depiler())#écrire Pile Vide!

Remarque:

L'élément 9 n'est pas ajouté à la pile, par conséquent la taille ne change pas.

Il existe beaucoup de méthodes autres que celles qu'on a décrit ci-dessus, vous pouvez ajouter des méthodes pour retourner l'élément du sommet, pour vérifier si la pile est vide etc.

---

Posted on Utopian.io - Rewarding Open Source Contributors

---