TP - Série N° 1

Exercice 1 :
somme = 0

for i in range(1, 101):

if i % 3 == 0 or i % 5 == 0:
continue
somme += i

print("La somme des entiers de 1 à 100 (en ignorant les multiples de 3 et 5) est :", somme)

Exercice 2 :
import random

nombre_secret = random.randint(1, 100) # Choisir un nombre secret entre 1 et 100

tentatives_restantes = 5 # Nombre de tentatives disponibles pour deviner
trouve = False

print("Devinez le nombre secret entre 1 et 100. Vous avez 5 tentatives.")

while tentatives_restantes > 0:

guess = int(input("Devinez le nombre : "))

if guess == nombre_secret:
trouve = True
break
elif guess < nombre_secret:
print("Le nombre secret est plus grand.")
else:
print("Le nombre secret est plus petit.")

tentatives_restantes -= 1

if trouve:
print("Bravo ! Vous avez trouvé le nombre secret :", nombre_secret)
else:
print("Désolé, vous n'avez pas trouvé. Le nombre secret était :", nombre_secret)

Exercice 3 :
nombre_entier = int(input("Entrez un nombre entier : "))

if nombre_entier < 0:
print("La factorielle n'est définie que pour les nombres entiers non négatifs.")
else:
resultat_factorielle = 1
for i in range(2, nombre_entier + 1):
resultat_factorielle *= i
 print("La factorielle de {} est : {}".format(nombre_entier, resultat_factorielle))

TP - Série N° 2
Exercice 1 :
def tri_selection(arr):
n = len(arr)
for i in range(n):
min_index = i
for j in range(i + 1, n):
if arr[j] < arr[min_index]:
min_index = j
temp = arr[i]
arr[i] = arr[min_index]
arr[min_index] = temp
return arr
tri_selection([3,6,0,1,7,2])

Exercice 2 :
Version 1:
def est_palindrome(chaine):

# Comparer la chaîne avec sa version inversée

return chaine == chaine[::-1]

# Exemple d'utilisation
mot = "radar"
if est_palindrome(mot):
print(mot," est un palindrome !")
else:
print(mot," n'est pas un palindrome.")

Version 2 :
def est_palindrome(chaine):

# Convertir la chaîne en liste de caractères

liste_caracteres = list(chaine)

# Créer une copie inversée de la liste

liste_inverse = list(liste_caracteres)
liste_inverse.reverse()

# Comparer les listes pour vérifier si c'est un palindrome

return liste_caracteres == liste_inverse

# Exemple d'utilisation
mot = "radar"
if est_palindrome(mot):
print(mot," est un palindrome !")
else:
print(mot," n'est pas un palindrome.")
Version 3 :
def est_palindrome(chaine):

longueur = len(chaine)
est_pal = True

# Parcourir la moitié de la chaîne

for i in range(longueur // 2):
# Comparer les éléments opposés
if chaine[i] != chaine[longueur - i - 1]:
est_pal = False
break

return est_pal

# Exemple d'utilisation
mot = "radar"
if est_palindrome(mot):
print(mot," est un palindrome !")
else:
print(mot," n'est pas un palindrome.")

Exercice 3 :
Version 1 :
def unique_elements(input_list):
return set(input_list)

# Exemple d'utilisation
example_list = [1, 2, 2, 3, 4, 4, 5]
unique_elements_set = unique_elements(example_list)
unique_elements_set
Version 2 :
def count_unique_elements(input_list):

unique_elements = []
for element in input_list:
if element not in unique_elements:
unique_elements.append(element)
return len(unique_elements)

# Exemple d'utilisation
example_list = [1, 2, 2, 3, 4, 4, 5]
unique_count = count_unique_elements(example_list)
unique_count
TP - Série N° 3
Exercice 1 :
# Création d'un dictionnaire avec des clés "nom" et "âge"
dict = {
"nom": "Alice",
"âge": 30
}
# Ajout d'une nouvelle paire clé-valeur pour la "ville"
dict["ville"] = "Paris"

# Affichage de l'âge à partir du dictionnaire

age = dict["âge"]
age

Exercice 2 :
# Création d'un tuple avec quelques valeurs
tuple1 = (5, 10, 15)
En essayant de modifier une des valeurs du tuple `tuple1`, on rencontre l'erreur suivante : "'tuple' object
does not support item assignment". Cela confirme que les tuples en Python sont immuables, ce qui
signifie qu'on ne peut pas modifier leurs éléments une fois qu'ils ont été créés.
Exercice 3 :
Version 1 :
# Création de deux sets
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

# Trouver l'intersection de ces deux sets

intersection_initial = set1.intersection(set2)

# Ajout d'un élément à set1

set1.add(8)

# Vérifier à nouveau l'intersection après l'ajout

intersection_apres_ajout = set1.intersection(set2)

intersection_initial, intersection_apres_ajout
version 2 :
# Création des deux ensembles
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

# Trouver l'intersection entre set1 et set2

intersection = set()

# Parcours des éléments pour trouver l'intersection

for element in set1:
if element in set2:
intersection.add(element)

# Afficher l'intersection initiale

print("Intersection initiale :", intersection)

# Ajouter un élément à set1

set1.add(6)

# Trouver à nouveau l'intersection après l'ajout

nouvelle_intersection = set()

# Parcours des éléments pour trouver la nouvelle intersection

for element in set1:
if element in set2:
nouvelle_intersection.add(element)

# Afficher la nouvelle intersection

print("Nouvelle intersection :", nouvelle_intersection)
Exercice 3 :
Exercice 4 :
Version 1 :
# Définition de la fonction calcul_moyenne
def calcul_moyenne(liste):
if liste: # Vérifier si la liste n'est pas vide
return sum(liste) / len(liste)
else:
return 0 # Retourner 0 pour une liste vide

# Appel de la fonction avec une liste de nombres

liste_nombres = [10, 20, 30, 40, 50]
moyenne = calcul_moyenne(liste_nombres)
moyenne
Version 2 :
# la fonction calcul_moyenne
def calcul_moyenne(liste):
total = 0
for element in liste:
total += element
if len(liste) > 0:
return total / len(liste)
else:
return 0 # Retourner 0 pour une liste vide

# Appel de la fonction avec une liste de nombres

liste_nombres = [10, 20, 30, 40, 50]
moyenne = calcul_moyenne(liste_nombres)
moyenne
Exercice 5 :
Version 1 :
def merge_dicts(dict1, dict2):
"""
Fusionne deux dictionnaires en un seul. Si une clé est présente dans les deux dictionnaires,
la valeur de dict2 sera utilisée.
"""
merged_dict = dict1.copy() # Copie de dict1 pour ne pas le modifier directement
merged_dict.update(dict2) # Mise à jour avec les éléments de dict2
return merged_dict

# Exemple d'utilisation
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged_dict_example = merge_dicts(dict1, dict2)
merged_dict_example

version 2 :
def merge_dicts(dict1, dict2):
for key in dict2: # Parcours des clés de dict2
dict1[key] = dict2[key] # Met à jour ou ajoute les éléments de dict2 dans dict1

return dict1

# Exemple d'utilisation
dictionnaire1 = {"c": 3, "b": 2}
dictionnaire2 = {"c": 3, "d": 4}

resultat_fusion = merge_dicts(dictionnaire1, dictionnaire2)

print("Dictionnaire fusionné :", resultat_fusion)
version 3 :
def merge_dicts_alternative(dict1, dict2):
"""
Fusionne deux dictionnaires en un seul en utilisant une approche alternative.
Si une clé est présente dans les deux dictionnaires, la valeur de dict2 sera utilisée.
"""
return {**dict1, **dict2}

merged_dict_alternative = merge_dicts_alternative(dict1, dict2)

merged_dict_alternative

Exercice 6 :
def unique_elements(input_list):
return set(input_list)

# Exemple d'utilisation
example_list = [1, 2, 2, 3, 4, 4, 5]
unique_elements_set = unique_elements(example_list)
unique_elements_set