27 Questions et 6 exercices corrigés sur les chaînes de caractères en Python 3

Chaines Caracteres Python

Premièrement, rappelons que le caractère espace blanc et les caractères \t, \f, \v, \r et \n sont appelés des caractères blancs.

Exercice 1

Ecrire les fonctions suivantes:
1. longueur(ch) qui calcule la le nombre de caractères d’une chaîne de caractères.

def longueur(ch):
    i=0
    for c in ch:
        i+=1
    return i

 

2. Mnscl(caractere) qui retourne True si le caractère est minuscule, False sinon.

def Mnscl(caractere):
    if len(caractere)==1:
        if ord(caractere)>=97 and  ord(caractere)<=122:
            return True
    
    return False

 

3. Maj(caractere) qui retourne True si le caractère est majuscule, False sinon.

def Maj(caractere):
    if len(caractere)==1:
        if ord(caractere)>=65 and  ord(caractere)<=90:
            return True
    
    return False

 

4. Maxc(ch) qui retourne le caractère ayant le plus grand code ASCII.

def Maxc(ch): 
    code_ascii=0
    car=""
    
    for c in ch:
        if ord(c)>code_ascii:
            code_ascii=ord(c)
            car=c
            
    return car

 

5. Minc(ch) qui retourne le caractère ayant le plus petit code ASCII.

def Minc(ch): 
    code_ascii=255
    car=""
    
    for c in ch:
        if ord(c)<code_ascii:
            code_ascii=ord(c)
            car=c
    
    return car

 

Exercice 2

Ecrire les fonctions suivantes:
1. maxl(ch) qui retourne la lettre ayant le plus grand rang dans l’alphabet.

def Maxl(ch): 
    rang=0
    car=""
    
    for c in ch:
        if Maj(c) and ord(c)-64>rang:
            rang=ord(c)-64
            car=c
        elif Mnscl(c) and ord(c)-96>rang:
            rang=ord(c)-96
            car=c
            
    if rang!=0:
        return car

 

2. minl (ch) qui retourne la lettre ayant le plus petit rang dans l’alphabet.

def Minl(ch): 
    rang=26
    car=""
    
    for c in ch:
        if Maj(c) and ord(c)-64<rang:
            rang=ord(c)-64
            car=c
        elif Mnscl(c) and ord(c)-96<rang:
            rang=ord(c)-96
            car=c
            
    if rang!=26:
        return car

 

3. estAlphaNum(ch) qui renvoie True si les caractères dans cette chaîne sont alphanumériques et il y a au moins un caractère.

def estAlphaNum(ch): 
    if len(ch)!=0:
        etat=True
        
        for c in ch:
            condition=Maj(c) or Mnscl(c) or (c in "0123456789")
            
            if not condition:
                etat= False
                break
                
        return etat
    else:
        return False

 

4. estAlpha(ch) qui renvoie True si les caractères dans cette chaîne sont alphabétiques et il y a au moins un caractère.

def estAlpha(ch):
    if len(ch)!=0: 
        etat=True
        
        for c in ch:
            condition=Maj(c) or Mnscl(c)
            
            if not condition:
                etat= False
                break
                
        return etat
    else:
        return False

 

5. estNum(ch) qui renvoie True si cette chaîne ne contient que des caractères numériques.

def estNum(ch):
    if len(ch)!=0:
        etat=True
        
        for c in ch:
            if c not in "0123456789":
                etat= False
                break
                
        return etat
    else:
        return False

 

Exercice 3

Ecrire les fonctions suivantes:
1. estMnscl (ch) qui renvoie True si tous les caractères dans cette chaîne est des lettres minuscules et il y a au moins un caractère.

def estMnscl (ch):
    if len(ch)!=0:
        etat=True
        
        for c in ch:
            if not Mnscl(c):
                etat= False
                break
                
        return etat
    else:
        return False

 

2. estMaj(ch) qui renvoie True si tous les caractères dans cette chaîne sont des lettres majuscules et il y a au moins un caractère.

def estMaj(ch):
    if len(ch)!=0:
        etat=True
        
        for c in ch:
            if not Maj(c):
                etat= False
                break
                
        return etat
    else:
        return False

 

3. estEspace(ch) qui renvoie True si cette chaîne ne contient que des caractères blancs.

def estEspace(ch):
    if len(ch)!=0:
        etat=True
        
        for c in ch:
            if c not in " \t\f\v\r\n":
                etat= False
                break
                
        return etat
    else:
        return False

 

4. seTerminePar(s1, ch) qui renvoie True si la chaîne ch se termine par la sous-chaîne s1.

def seTerminePar(s1, ch):
    return s1==ch[len(ch)-len(s1):]

 

5. CommencePar(s1, ch) qui renvoie True si la chaîne ch commence par la sous-chaîne s1.

def CommencePar(s1, ch):
    return s1==ch[0:len(s1)]

 

Exercice 4

Ecrire les fonctions suivantes:
1. Trouver(s1, ch) qui retourne l’indice le plus bas où s1 commence dans cette chaîne, ou -1 si s1 ne se trouve pas dans cette chaîne.

def Trouver(s1, ch): 
   if len(ch)>=len(s1):
      i=0
      while i<=len(ch)-len(s1):
         if ch[i:i+len(s1)]==s1:
            return i
         i=i+1
   
   return -1

 

2. TrouverDroite(s1, ch) qui renvoie l’indice le plus élevé où s1 commence dans cette chaîne, ou -1 si s1 ne se trouve pas dans cette chaîne.

def TrouverDroite(s1, ch):
    pos=-1
   if len(ch)>=len(s1):
      i=0
      while i<=len(ch)-len(s1):
         if ch[i:i+len(s1)]==s1:
            pos= i
         i=i+1
   
   return pos

 

3. Compter(s) qui renvoie le nombre d’occurrences de s1.

def Compter(s1, ch):
    compteur=0
   if len(ch)>=len(s1):
      i=0
      while i<=len(ch)-len(s1):
         if ch[i:i+len(s1)]==s1:
            compteur+=1
         i=i+1
   
   return compteur

 

4. PremierMaj() qui renvoie une copie de cette chaîne avec seulement le premier caractère en majuscule.

def PremierMaj(ch):
    if len(ch)!=0:
        if Mnscl(ch[0]):
            return chr(ord(ch[0])-32)+ch[1:]
        else:
            return ch

 

5. ConvertirMnscl(ch) qui renvoie une copie de cette chaîne avec toutes les lettres converties en minuscules.

def ConvertirMscl(ch):
   s=""
   for c in ch:
      if Maj(c):
         s=s+chr(ord(c)+32)
      else:
         s=s+c
    return s

 

Exercice 5

Ecrire les fonctions suivantes:
1. ConvertirMaj (ch) qui renvoie une copie de cette chaîne avec toutes les lettres converties en majuscules.

def ConvertirMaj(ch):
   s=""
   for c in ch:
      if Mnscl(c):
         s=s+chr(ord(c)-32)
      else:
         s=s+c
    return s

 

2. Titre(ch) qui renvoie une copie de cette chaîne avec la première lettre en majuscule dans chaque mot.

def Titre(ch):
    etat=1
    s=""
    for c in ch:
        if etat==1 and Mnscl(c):
            car=chr(ord(c)-32)
            etat=0
        elif c==" ":
            etat=1
            car=c
        else:
            car=c
            
        s=s+car
    return s

 

3. ChangerCasse(ch) qui renvoie une copie de cette chaîne dans laquelle les lettres minuscules converties en majuscules et les lettres en majuscules converties en minuscules.

def ChangerCasse(ch):
    s=""
    for c in ch:
        if Maj(c):
            car=chr(ord(c)+32)
        elif Mnscl(c):
            car=chr(ord(c)-32)
        else:
            car=c
            
        s=s+car
    return s

 

4. Remplacer(ch,ancien, nouveau) qui retourne une nouvelle chaîne qui remplace toutes les occurrences de la chaîne ancien par la chaîne nouveau.

def Remplacer(ch,ancien, nouveau):
   if len(ch)>=len(ancien):
      i=0
      while i<=len(ch)-len(ancien):
         if ch[i:i+len(ancien)]==ancien:
            ch=ch[:i]+nouveau+ch[i+len(ancien):]
            i=i+len(nouveau)
         else:
            i=i+1
        return ch
    else:
        return ch

 

Exercice 6

Ecrire les fonctions suivantes:
1. SupprEspG(ch) qui retourne une chaîne avec les caractères blancs en début enlevés.

def SupprEspG(ch):
    if len(ch)!=0:
        s=""
        etat=1
        for c in ch:
            if c in " \t\f\v\r\n" and etat==1:
                continue
            else:
                s=s+c
                etat=0
        return s
    else:
        return ch

 

2. SupprEspGD(ch) qui retourne une chaîne avec les caractères blancs à droite supprimés.

def SupprEspD(ch):
    def inverser(ch):
        s=""
        for c in ch:
            s=c+s
        return s
    
    ch= SupprEspG(inverser(ch))
    
    return inverser(ch)

3. SupprEsp(ch) qui retourne une chaîne sans caractères blancs à gauche et droite.

def SupprEsp(ch):
    return SupprEspD(SupprEspG(ch))

 

LAISSER UN COMMENTAIRE

Please enter your comment!
Please enter your name here