Catégorie dans Imagerie

Programme Python pour vérifier si une chaîne est palindrome ou non

Voici un exemple de code Python qui vérifie si une chaîne est un palindrome ou non :

 

def est_palindrome(s):
    # On retire les espaces et on met tout en minuscule
    s = s.replace(" ", "").lower()

    # On inverse la chaîne
    s_inverse = s[::-1]

    # On compare la chaîne et son inverse
    if s == s_inverse:
        return True
    else:
        return False

# Testons avec quelques exemples
print(est_palindrome("radar")) # True
print(est_palindrome("Bonjour")) # False
print(est_palindrome("Bob")) # True

Ce code fonctionne en suivant ces étapes :

  1. On enlève les espaces de la chaîne et on met tous les caractères en minuscule, pour éviter les problèmes de casse et d’espaces.
  2. On inverse la chaîne en utilisant la slicing syntax
    [start:end:step]

    avec un

    step

    de

    -1

    .

  3. On compare la chaîne originale et son inverse, et on renvoie
    True

    si elles sont égales et

    False

    sinon.

Quelle est la différente entre les tuples et liste en python?

En Python, les tuples et les listes sont des structures de données similaires qui permettent de stocker une série d’éléments. Cependant, il y a quelques différences importantes entre ces deux types :

  1. Les tuples sont immuables, c’est-à-dire que vous ne pouvez pas ajouter, supprimer ou modifier des éléments d’un tuple une fois qu’il a été créé. Les listes, en revanche, sont mutables et vous pouvez facilement ajouter, supprimer ou modifier des éléments.
  2. Les tuples sont généralement plus rapides à créer et à manipuler que les listes, car ils sont immuables. Cependant, cela dépend de l’opération que vous effectuez.
  3. Les tuples sont définis avec des parenthèses
    ()

    , tandis que les listes sont définies avec des crochets

    []

    .

Voici un exemple de création et de modification de tuples et de listes en Python :

 

# Création d'un tuple et d'une liste
tuple = (1, 2, 3)
list = [1, 2, 3]

# Tentative de modification d'un élément du tuple (échoue)
try:
    tuple[0] = 0
except TypeError:
    print("Impossible de modifier un élément d'un tuple")

# Modification d'un élément de la liste
list[0] = 0
print(list)  # imprime [0, 2, 3]

# Tentative d'ajout d'un élément au tuple (échoue)
try:
    tuple.append(4)
except AttributeError:
    print("Impossible d'ajouter un élément à un tuple")

# Ajout d'un élément à la liste
list.append(4)
print(list)  # imprime [0, 2, 3, 4]

 

Comment itérer sur une liste python

Il y a plusieurs façons d’itérer sur une liste en Python. Voici quelques exemples :

En utilisant une boucle

for

classique :

numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number)
    1. En utilisant la fonction
      enumerate

      :

    2. numbers = [1, 2, 3, 4, 5]
      for i, number in enumerate(numbers):
          print(f'Index {i}: {number}')
      
    3. En utilisant la fonction
      range

      et la boucle

      for

      :

      numbers = [1, 2, 3, 4, 5]
      for i in range(len(numbers)):
          print(f'Index {i}: {numbers[i]}')
      
    4. En utilisant la boucle
      while

      :

numbers = [1, 2, 3, 4, 5]
i = 0
while i < len(numbers):
    print(f'Index {i}: {numbers[i]}')
    i += 1

    Programme Python pour trouver la plus petite valeur dans une liste

    Voici comment vous pouvez écrire un programme Python pour trouver la plus petite valeur dans une liste :

     

    # déclarez une liste
    liste = [3, 5, 1, 2, 4]
    
    # définissez une variable pour stocker la valeur la plus petite
    min_value = liste[0]
    
    # parcourez la liste
    for valeur in liste:
       # si la valeur est inférieure à la valeur actuellement stockée dans la variable min_value, mettez à jour la variable
       if valeur < min_value:
          min_value = valeur
    
    # imprimez la valeur la plus petite
    print(min_value)
    

    Ce code parcourt la liste et met à jour la variable

    min_value

    avec la valeur la plus petite qu’il trouve. À la fin, il imprime la valeur de

    min_value

    , qui est la plus petite valeur de la liste.

    Voici comment vous pouvez écrire une fonction Python pour trouver la plus petite valeur dans une liste :

     

    def trouver_min(liste):
       # définissez une variable pour stocker la valeur la plus petite
       min_value = liste[0]
    
       # parcourez la liste
       for valeur in liste:
          # si la valeur est inférieure à la valeur actuellement stockée dans la variable min_value, mettez à jour la variable
          if valeur < min_value:
             min_value = valeur
    
       # renvoyez la valeur la plus petite
       return min_value
    
    # testez la fonction en passant une liste comme argument
    print(trouver_min([3, 5, 1, 2, 4])) # doit renvoyer 1
    print(trouver_min([-1, -5, -3, -2, -4])) # doit renvoyer -5
    

    La fonction

    trouver_min()

    prend une liste en argument et renvoie la valeur la plus petite de la liste en utilisant la même logique que le code précédent. Vous pouvez l’utiliser en la appelant avec une liste en argument, comme dans les exemples de test .

    Programme Python pour trouver la plus grande valeur dans une liste

    Voici un exemple de code Python qui peut être utilisé pour trouver la plus grande valeur dans une liste :

     

    def trouver_max(liste):
        # On initialise le maximum à la première valeur de la liste
        max = liste[0]
      
        # On parcourt la liste à partir de la deuxième valeur
        for i in range(1, len(liste)):
            # Si la valeur est supérieure au maximum actuel, on met à jour le maximum
            if liste[i] > max:
                max = liste[i]
      
        # On renvoie le maximum
        return max
    
    # On teste la fonction avec une liste de nombres
    liste = [3, 5, 2, 8, 1]
    max = trouver_max(liste)
    print(f"Le maximum de la liste est {max}.")
    

    ou

     

    Ce code parcourt la liste et met à jour la variable

    max_value

    avec la valeur la plus élevée qu’il trouve. À la fin, il imprime la valeur de

    max_value

    , qui est la plus grande valeur de la liste.

     

    # déclarez une liste
    liste = [3, 5, 1, 2, 4]
    
    # définissez une variable pour stocker la valeur la plus élevée
    max_value = liste[0]
    
    # parcourez la liste
    for valeur in liste:
       # si la valeur est supérieure à la valeur actuellement stockée dans la variable max_value, mettez à jour la variable
       if valeur > max_value:
          max_value = valeur
    
    # imprimez la valeur la plus élevée
    print(max_value)
    

     

    Programme Python pour faire une calculatrice simple

    Voici comment vous pouvez écrire une fonction Python pour créer une calculatrice simple:

     

    def calculatrice(op, a, b):
      if op == "+":
        return a + b
      elif op == "-":
        return a - b
      elif op == "*":
        return a * b
      elif op == "/":
        return a / b
      else:
        print("Opération non valide")
    
    

    Pour utiliser cette fonction, vous pouvez appeler

    calculatrice(op, a, b)

    , où

    op

    est l’opérateur (sous forme de chaîne de caractères), et

    a

    et

    b

    sont les opérandes (sous forme de nombres). La fonction renvoie le résultat de l’opération. Par exemple:

     

    >>> calculatrice("+", 1, 2)
    3
    >>> calculatrice("-", 4, 3)
    1
    >>> calculatrice("*", 5, 6)
    30
    >>> calculatrice("/", 8, 4)
    2.0
    

    Cette fonction utilise un

    if

    /

    elif

    /

    else

    pour vérifier l’opérateur et effectuer l’opération appropriée. Si l’opérateur n’est pas reconnu, la fonction imprime un message d’erreur.

    Notez que cette fonction ne gère pas les erreurs de division par zéro. Si vous souhaitez gérer cette erreur, vous pouvez utiliser un

    try

    /

    except

    pour attraper l’exception

    ZeroDivisionError

    qui sera levée dans ce cas.

     

    def calculatrice():
      while True:
        expression = input("Entrez une expression à évaluer (ou tapez 'q' pour quitter): ")
        if expression == 'q':
          break
        try:
          resultat = eval(expression)
          print("Résultat:", resultat)
        except Exception as e:
          print("Erreur:", e)
    
    

    Pour utiliser cette fonction, vous pouvez simplement l’appeler:

    calculatrice()

    . La fonction affichera un message demandant à l’utilisateur de saisir une expression à évaluer, et continuera à le faire tant que l’utilisateur n’a pas tapé ‘q’ pour quitter. Si l’utilisateur saisit une expression valide, la fonction utilise la fonction built-in

    eval()

    de Python pour évaluer l’expression et affiche le résultat. Si une erreur se produit lors de l’évaluation de l’expression (par exemple, si l’expression est mal formée), la fonction affiche l’erreur.

     

    >>> calculatrice()
    Entrez une expression à évaluer (ou tapez 'q' pour quitter): 2 + 2
    Résultat: 4
    Entrez une expression à évaluer (ou tapez 'q' pour quitter): 3 * 5
    Résultat: 15
    Entrez une expression à évaluer (ou tapez 'q' pour quitter): q
    

     

    def calculatrice(operation, a, b):
      if operation == '+':
        return a + b
      elif operation == '-':
        return a - b
      elif operation == '*':
        return a * b
      elif operation == '/':
        return a / b
      else:
        return "Opération non valide"
    
    

    Pour utiliser cette fonction, vous pouvez appeler

    calculatrice(operation, a, b)

    , où

    operation

    est une chaîne de caractères représentant l’opération à effectuer (par exemple, “+” pour l’addition, “-” pour la soustraction, etc.), et

    a

    et

    b

    sont les opérandes. La fonction renverra le résultat de l’opération. Par exemple:

     

    >>> calculatrice('+', 1, 2)
    3
    >>> calculatrice('-', 4, 2)
    2
    >>> calculatrice('*', 3, 3)
    9
    >>> calculatrice('/', 8, 4)
    2.0
    >>> calculatrice('^', 2, 3)
    "Opération non valide"
    

     

    Programme Python pour convertir décimal en binaire, octal et hexadécimal

    Voici comment vous pouvez écrire une fonction Python pour convertir un nombre décimal en binaire, octal et hexadécimal:

     

    def conversion(n):
      print("En binaire:", bin(n))
      print("En octal:", oct(n))
      print("En hexadécimal:", hex(n))
    
    

    Pour utiliser cette fonction, vous pouvez simplement appeler

    conversion(n)

    , où

    n

    est le nombre décimal que vous souhaitez convertir. La fonction imprimera les versions binaire, octale et hexadécimale de ce nombre. Par exemple:

    >>> conversion(10)
    En binaire: 0b1010
    En octal: 0o12
    En hexadécimal: 0xa
    

    Cette fonction utilise les fonctions built-in de Python

    bin()

    ,

    oct()

    et

    hex()

    pour effectuer les conversions. Ces fonctions renvoient les versions binaire, octale et hexadécimale des nombres en tant que chaînes de caractères, avec le préfixe

    0b

    ,

    0o

    et

    0x

    respectivement pour indiquer le type de chaque nombre.

    Programme Python pour imprimer la suite de Fibonacci

    Voici comment vous pouvez écrire une fonction Python pour imprimer les

    n

    premiers termes de la suite de Fibonacci:

     

    def fibonacci(n):
      if n == 0:
        return 0
      elif n == 1:
        return 1
      else:
        return fibonacci(n-1) + fibonacci(n-2)
    
    

    Pour utiliser cette fonction, vous pouvez simplement appeler

    fibonacci(n)

    , où

    n

    est le nombre de termes que vous souhaitez imprimer. Par exemple:

     

    >>> for i in range(10):
    ...   print(fibonacci(i))
    ... 
    0
    1
    1
    2
    3
    5
    8
    13
    21
    34
    

    Cette fonction utilise la définition récursive de la suite de Fibonacci, qui est la suivante:

    • le premier terme de la suite est 0
    • le second terme de la suite est 1
    • chaque terme suivant est la somme des deux termes précédents

    Cette fonction s’arrête lorsque

    n

    atteint 0 ou 1, ce qui signifie que la récursion s’arrête également. Vous pouvez utiliser une boucle

    for

    pour appeler la fonction plusieurs fois et imprimer chaque terme de la suite.

     

     

    def fibonacci(n):
      a, b = 0, 1
      while n > 0:
        print(a)
        a, b = b, a + b
        n -= 1
    
    

    Pour utiliser cette fonction, vous pouvez simplement appeler

    fibonacci(n)

    , où

    n

    est le nombre de termes de la suite que vous souhaitez imprimer. Par exemple:

    Cette fonction utilise la définition récursive de la suite de Fibonacci, qui est la suivante:

    • le premier terme est 0
    • le deuxième terme est 1
    • chaque terme suivant est la somme des deux termes précédents

    La fonction utilise deux variables,

    a

    et

    b

    , pour stocker les deux derniers termes de la suite. À chaque itération de la boucle

    while

    , elle imprime le terme actuel (qui est stocké dans

    a

    ), puis met à jour

    a

    et

    b

    pour qu’ils contiennent les deux derniers termes de la suite. La boucle s’arrête lorsque le nombre de termes demandé a été atteint.

     

    >>> fibonacci(5)
    0
    1
    1
    2
    3
    

     

    Programme Python pour vérifier le nombre premier

    Voici comment vous pouvez écrire une fonction Python pour vérifier si un nombre est premier:

     

    def est_premier(n):
      if n < 2:
        return False
      for i in range(2, n):
        if n % i == 0:
          return False
      return True
    
    

    Pour utiliser cette fonction, vous pouvez simplement appeler

    est_premier(n)

    , où

    n

    est le nombre que vous souhaitez vérifier. La fonction retournera

    True

    si le nombre est premier,

    False

    sinon.

     

    >>> est_premier(2)
    True
    >>> est_premier(3)
    True
    >>> est_premier(4)
    False
    >>> est_premier(17)
    True
    >>> est_premier(18)
    False
    

    Cette fonction utilise une boucle

    for

    qui parcourt tous les nombres entiers de 2 à n-1, et vérifie si n est divisible par l’un de ces nombres. Si c’est le cas, cela signifie que n n’est pas premier, et la fonction retourne

    False

    . Si aucun de ces nombres ne divise n, cela signifie que n est premier, et la fonction retourne

    True

    .

     

    def est_premier(n):
      if n < 2:
        return False
      for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
          return False
      return True
    
    

     

     

    Cette fonction utilise l’algorithme de vérification des nombres premiers suivant:

    1. Si le nombre est inférieur à 2, il n’est pas premier (les nombres premiers commencent à 2).
    2. Sinon, pour chaque nombre entier
      i

      allant de 2 à la racine carrée du nombre (arrondie à l’entier inférieur), vérifiez si le nombre est divisible par

      i

      .

    3. Si aucun de ces nombres ne divise le nombre, il est premier. Sinon, il ne l’est pas.

    Cette méthode est efficace pour les nombres relativement petits, mais pour les nombres plus grands, il existe des algorithmes plus efficaces pour vérifier si un nombre est premier.

    Programme Python pour trouver la factorielle d’un nombre

    Voici un exemple de code Python qui calcule la factorielle d’un nombre:

     

    def factorielle(n):
      if n == 0:
        return 1
      else:
        return n * factorielle(n-1)
    
    print(factorielle(5))  # affiche 120
    

    Ce code utilise une fonction récursive, c’est-à-dire qu’elle s’appelle elle-même avec un nombre moins grand jusqu’à ce qu’il atteigne 0. Lorsque n est égal à 0, la fonction renvoie 1, sinon elle renvoie n multiplié par la factorielle de n-1. Par exemple, pour calculer la factorielle de 5, la fonction s’appelle elle-même avec 4, puis avec 3, puis avec 2, puis avec 1, puis avec 0, et finalement renvoie 1 * 2 * 3 * 4 * 5 = 120.

     

    Cette fonction utilise la définition récursive de la factorielle, qui est la suivante:

    • la factorielle de 0 est 1
    • la factorielle de n (n>0) est n * la factorielle de n-1

    Cette fonction s’arrête lorsque n atteint 0, ce qui signifie que la récursion s’arrête également.


    1 2 3 4 5 6 7 8 9 10 11 12 13 14