Correction 

:
1 ère méthode
dicPC={"HP": 11 , "Acer": 7 , "Lenovo": 17 , "Del":
23}
dicPhone={"Sumsung": 22 , "Iphone": 9 , "Other": 13 }
dicTablette = {"Sumsung": 15 , "Other": 13}
 
# on crée un dictionnaire vide qui va contenir les
autres dictionnaires
dicTotal = {}
 
# on ajoute les dictionnaire un par un via la méthode
update
dicTotal.update(dicPC)
dicTotal.update(dicPhone)
dicTotal.update(dicTablette)
print(dicTotal)
2ème méthode
dicPC={"HP": 11 , "Acer": 7 , "Lenovo": 17 , "Del":
23}
dicPhone={"Sumsung": 22 , "Iphone": 9 , "Other": 13 }
dicTablette = {"Sumsung": 15 , "Other": 13}
# on crée un dictionnaire qui va contenir les autres
dicTotal = {}
# on ajoute les dictionnaires via la boucle for
for d in [dicPC , dicTablette, dicPhone]:
dicTotal.update(d)
 
print(dicTotal)
 
# demander à l'utilisateur de saisir un texte
T = input("Saisir un texte : ")
 
# Convertir le texte en une liste
liste_words = T.split()
 
# création du dictionnaire demandé
d = dict({})
for word in liste_words:
    d[word] = len(word)
    
print("Le dictionnaire demandé est " , d)
# ce qui affiche pour le texte cité ci-dessus:
# Le dictionnaire demandé est  {'Python': 6, 'est': 3, 'un': 2, 'langage':
7, 'de': 2, 'programmation': 13}
 
def listTuples(L):
    # initialisation de la liste des tuples
    lTuples = []
    for n in L:
        for m in L:
            if m + n < 10:
                lTuples.append((m,n))
    return lTuples
# Exemple
L = [11 , 3  ,  2 , 22 , 4 , 31 , 18 , 6,  12 ,  1 , 7]
print(listTuples(L))
def twoMajConsecutive(s):
    # initialisation de la liste recherchée
    L_2_maj = []
    
    # convertir la chaine de caractère s en une liste
    list_word = s.split()
    
    # parcourir les mots de la liste
    for word in list_word:
        # rechercher les majuscules succéssives
        for i in range(0 , len(word)-1):
            if word[i:i+2].isupper() and word not in L_2_maj:
                L_2_maj.append(word)
    return L_2_maj
 
# Exemple
s = "SQLite et  MongoDB sont beaucoup plus simple que les bases de
données PostgreSQL et Oracle"
print(twoMajConsecutive(s))
# le programme affiche: ['SQLite', 'MongoDB', 'PostgreSQL']
def tuples_items_Occ(L):
    # initialisation de la liste des tuples
    listItemsOcc = []
    for x in L:
        if (x , L.count(x)) not in listItemsOcc:
            listItemsOcc.append((x , L.count(x)))
    return listItemsOcc

# Exemple
L = [22 , 7 , 14 , 22 , 7 , 14 , 7 , 14 , 11 , 7]
print (tuples_items_Occ(L))
#La sortie du programme est:
#[(22, 2), (7, 4), (14, 3), (11, 1)]
def cul_de_chouette(valeur):
# Initialisation du résultat
res=list()  
# Premier dé
for i in range(1, 7):
for j in range(i, 7):
for k in range(j, 7):
# Si la somme des dés a la bonne
valeur on complète la liste des résultats
if (i+j+k) == valeur:
res.append((i, j, k))
 
# Tirage terminé - Renvoi des résultats trouvés
return res
# cul_de_chouette()
 
# Affichage des tirages qui correspondent
for c in cul_de_chouette(7):
print(c)
def heureux(nb):
    etat = False  # etat du nombre, est ce que c'est
heureux ou non par défaut le nombre n'est pas heureux
    # verifier est ce que le nombre est inférieur à
10
    nombre = str(nb)
    limite = False
    while limite == False:
        s = 0
        for i in nombre:
            s += int(i)**2
        nombre = str(s)
        if nombre == '1':
            etat = True
            break
        if int(nombre) < 10:  # si le nombre<10 donc
limite=True
            limite = True
    return etat
print(heureux(7))
def robinson(n):
    U = 0
    for _ in range(1, n+1):
        ch = str(U)
        L = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        for chiffre in ch:
            L[int(chiffre)] += 1
        res = ''
        for j in range(9, -1, -1):
            if L[j] != 0:
                res += str(L[j])+str(j)
        U = int(res)
    print('Terme : ', n, ' est ', U)
 
robinson(5)
#!/usr/bin/env python3
# coding: utf-8

# Objet pour gérer un point dans le plan

class cPoint:
# Le constructeur du point
def __init__(self, x=0, y=0):
(self.x, self.y)=(x, y)
# __init__()

# L'affichage d'un point

def __str__(self):
return "x={}, y={}".format(self.x, self.y)
# __str__()

# Distance entre deux points

# Cette méthode appartient à l'objet, mais ne concerne aucun
point en particulier
# Elle concerne donc tous les points en général
# Elle est donc générale à l'objet
# Elle est donc statique
@staticmethod
def distance(a, b):
return ((a.x - b.x) ** 2 + (a.y - b.y) ** 2) ** 0.5
# distance()
# cPoint()

# Tests
a=cPoint(2, 3)
print("a=", a, type(a))
b=cPoint(6, 6)
print("b=", b, type(b))
print("distance=", cPoint.distance(a, b))
#coding: utf-8
class CompteBancaire:
def __init__(self, idNumber, nomPrenom, solde):
self.idNumber = idNumber
self.nomPrenom = nomPrenom
self.solde = solde

def versement(self, argent):

self.solde = self.solde + argent

def retrait(self, argent):

if(self.solde < argent):
print(" Impossible d'effectuer l'opération. Solde
insuffisant !")
else:
self.solde = self.solde - argent

def agios(self):
self.solde =self.solde*95/100

def afficher(self):
print("Compte numéro : " , self.idNumber)
print("Nom & Prénom : ", self.nomPrenom)
print(" Solde : ", self.solde , " DH ")
print("Sauf erreur ou omisssion ! ")

monCompte = CompteBancaire(16168891, " Bouvier David",

22300)
monCompte.versement(1500)
monCompte.retrait(24000)
#monCompte.agios()
monCompte.afficher()