Python >> Tutoriel Python >  >> Python

Supprimer une partie d'une chaîne en Python

Cet article décrit comment supprimer une partie d'une chaîne str en Python.

  • Supprimer une sous-chaîne en la remplaçant par une chaîne vide
    • Supprimer la chaîne de correspondance exacte :replace()
    • Supprimer les sous-chaînes par regex :re.sub()
  • Supprimer les caractères de début et de fin :strip()
  • Supprimer les premiers caractères :lstrip()
  • Supprimer les caractères de fin :rstrip()
  • Supprimer le préfixe :removeprefix() (Python 3.9 ou version ultérieure)
  • Supprimer le suffixe :removesuffix() (Python 3.9 ou version ultérieure)
  • Supprimer une sous-chaîne par position et longueur :slice
  • Pour une liste de chaînes
  • Pour une chaîne avec des sauts de ligne
    • Supprimer une partie de la chaîne dans chaque ligne
    • Supprimer les lignes selon l'état

Consultez l'article suivant pour savoir comment supprimer des extensions et des parties de répertoire d'une chaîne de chemin.

    Supprimer une sous-chaîne en la remplaçant par une chaîne vide

    Vous pouvez supprimer une sous-chaîne en la remplaçant par une chaîne vide '' .

    Seuls des exemples simples de replace() et re.sub() sont montrés ici. Pour plus d'informations sur le remplacement de chaîne, consultez l'article suivant.

      Supprimer la chaîne de correspondance exacte :replace()

      Vous pouvez remplacer une chaîne qui correspond exactement à la chaîne donnée par le replace() méthode de la chaîne str . S'il est remplacé par une chaîne vide '' , il est supprimé.

      s = 'abc-xyz-123-789-ABC-XYZ'
      
      print(s.replace('xyz', ''))
      # abc--123-789-ABC-XYZ
      

      Supprimer les sous-chaînes par regex :re.sub()

      Vous pouvez supprimer les sous-chaînes correspondant à l'expression régulière (regex) avec sub() dans le module d'expression régulière re .

      L'exemple suivant utilise le modèle d'expression régulière \d+ , qui correspond à une séquence d'un ou plusieurs nombres. 123 et 789 sont remplacés par la chaîne vide '' et supprimé.

      import re
      
      s = 'abc-xyz-123-789-ABC-XYZ'
      
      print(re.sub('\d+', '', s))
      # abc-xyz---ABC-XYZ
      

      Supprimer les caractères de début et de fin :strip()

      Utilisez strip() pour supprimer les caractères spécifiés au début et à la fin d'une chaîne.

        Par défaut, les caractères d'espacement consécutifs aux deux extrémités sont supprimés. Nouvelles lignes \n , espaces pleine chasse \u3000 , onglets \t , etc. sont considérés comme des caractères d'espacement.

        s = ' \n a b c \t'
        
        print(s)
        #  
        #  a b c    
        
        print(repr(s))
        # ' \n a b c\u3000\t'
        
        print(s.strip())
        # a b c
        
        print(repr(s.strip()))
        # 'a b c'
        

        Ici, la fonction intégrée repr() est utilisé pour imprimer des caractères d'espacement.

          strip() renvoie un nouvel objet et l'objet d'origine reste inchangé. Vous pouvez affecter le résultat à la variable d'origine. Il en va de même pour les autres méthodes de chaîne, replace() , lstrip() , et rstrip() .

          s_strip = s.strip()
          print(repr(s_strip))
          # 'a b c'
          
          print(repr(s))
          # ' \n a b c\u3000\t'
          
          s = s.strip()
          print(repr(s))
          # 'a b c'
          

          Lorsqu'une chaîne est passée à strip() , les caractères de la chaîne sont supprimés des deux côtés.

          Les caractères de la chaîne spécifiée sont supprimés, pas la chaîne qui correspond à la chaîne spécifiée. Par exemple, le résultat est le même pour 'abc' ou 'cba' . Si vous souhaitez supprimer les chaînes correspondantes aux deux extrémités, utilisez removeprefix() et removesuffix() décrit ci-dessous.

          s = 'aabbcc-abc-aabbcc'
          
          print(s.strip('abc'))
          # -abc-
          
          print(s.strip('cba'))
          # -abc-
          
          print(s.strip('ab'))
          # cc-abc-aabbcc
          

          Si une chaîne est spécifiée, les caractères d'espacement ne sont pas supprimés.

          s = ' \n aabbcc-abc-aabbcc \t'
          
          print(repr(s))
          # ' \n aabbcc-abc-aabbcc\u3000\t'
          
          print(repr(s.strip('abc')))
          # ' \n aabbcc-abc-aabbcc\u3000\t'
          

          Si vous souhaitez également supprimer les caractères d'espacement, vous devez le spécifier explicitement ou appliquer strip() à plusieurs reprises.

          print(repr(s.strip('abc \n \t')))
          # '-abc-'
          
          print(repr(s.strip().strip('abc')))
          # '-abc-'
          

          Supprimer les caractères de tête :lstrip()

          Utilisez lstrip() pour supprimer uniquement les caractères de début. l est pour left .

            L'utilisation est la même que strip() .

            s = ' \n a b c  \t'
            
            print(repr(s.lstrip()))
            # 'a b c \u3000\t'
            
            s = 'aabbcc-abc-aabbcc'
            
            print(s.lstrip('abc'))
            # -abc-aabbcc
            

            Supprimer les caractères de fin :rstrip()

            Utilisez rstrip() pour supprimer uniquement les caractères de fin. r est pour right .

              L'utilisation est la même que strip() .

              s = ' \n a b c  \t'
              
              print(repr(s.rstrip()))
              # ' \n a b c'
              
              s = 'aabbcc-abc-aabbcc'
              
              print(s.rstrip('abc'))
              # aabbcc-abc-
              

              Supprimer le préfixe :removeprefix() (Python 3.9 ou version ultérieure)

              removeprefix() a été ajouté dans Python 3.9.

                S'il commence par le préfixe spécifié, une chaîne avec le préfixe supprimé est renvoyée. S'il n'y a pas de correspondance, la chaîne d'origine est renvoyée telle quelle.

                s = 'abc-abcxyz'
                
                print(s.removeprefix('abc-'))
                # abcxyz
                
                print(s.removeprefix('aabc-'))
                # abc-abcxyz
                

                lstrip() supprime tous les caractères de la chaîne spécifiée.

                print(s.lstrip('abc-'))
                # xyz
                

                Dans les versions où removeprefix() n'est pas fourni, vous pouvez définir la fonction suivante.

                def my_removeprefix(s, prefix):
                    if s.startswith(prefix):
                        return s[len(prefix):]
                    else:
                        return s
                
                print(my_removeprefix(s, 'abc-'))
                # abcxyz
                

                Comme indiqué dans le removesuffix() suivant , cette fonction peut également être écrite à l'aide de l'expression conditionnelle.

                Supprimer le suffixe :removesuffix() (Python 3.9 ou version ultérieure)

                removesuffix() a été ajouté dans Python 3.9.

                  Le concept est le même que removeprefix() .

                  s = 'abcxyz-xyz'
                  
                  print(s.removesuffix('-xyz'))
                  # abcxyz
                  
                  print(s.removesuffix('-xyzz'))
                  # abcxyz-xyz
                  

                  Dans les versions où removesuffix() n'est pas fourni, vous pouvez définir la fonction suivante à l'aide de l'expression conditionnelle.

                    def my_removesuffix(s, suffix):
                        return s[:-len(suffix)] if s.endswith(suffix) else s
                    
                    print(my_removesuffix(s, '-xyz'))
                    # abcxyz
                    

                    Si vous souhaitez supprimer à la fois le préfixe et le suffixe, exécutez simplement removeprefix() et removesuffix() .

                    s = 'abc-abcxyz-xyz'
                    
                    print(s.removeprefix('abc-').removesuffix('-xyz'))
                    # abcxyz
                    
                    print(my_removeprefix(my_removesuffix(s, '-xyz'), 'abc-'))
                    # abcxyz
                    

                    Supprimer une sous-chaîne par position et longueur :tranche

                    Vous pouvez utiliser des tranches pour obtenir une partie d'une chaîne à une position donnée.

                      s = '0123456789'
                      
                      print(s[3:7])
                      # 3456
                      
                      print(s[3:-3])
                      # 3456
                      
                      print(s[:5])
                      # 01234
                      
                      print(s[5:])
                      # 56789
                      

                      Si vous souhaitez supprimer les deux extrémités d'une chaîne, vous pouvez spécifier la partie à conserver à l'aide de tranches. Par exemple, supprimer le 6ème caractère ou plus équivaut à passer au 5ème caractère.

                      Pour supprimer la chaîne intérieure, coupez les parties à gauche des deux extrémités et concaténez-les avec le + opérateur.

                        print(s[:3] + s[6:])
                        # 0126789
                        

                        Par exemple, vous pouvez définir les fonctions suivantes.

                        Fonction pour supprimer une sous-chaîne de start à end (dont end ):

                        def remove_str_start_end(s, start, end):
                            return s[:start] + s[end + 1:]
                        
                        print(remove_str_start_end(s, 3, 5))
                        # 0126789
                        

                        Fonction pour supprimer une sous-chaîne de length caractères de start .

                        def remove_str_start_length(s, start, length):
                            return s[:start] + s[start + length:]
                        
                        print(remove_str_start_length(s, 3, 5))
                        # 01289
                        

                        Pour une liste de chaînes

                        Pour une liste de chaînes, utilisez la compréhension de liste pour appliquer des méthodes de chaîne telles que strip() et découper chaque élément.

                          l = ['Alice', 'Bob', 'Charlie']
                          
                          print([s.strip('bce') for s in l])
                          # ['Ali', 'Bo', 'Charli']
                          
                          print([s[:2] for s in l])
                          # ['Al', 'Bo', 'Ch']
                          

                          Pour une chaîne avec des sauts de ligne

                          Utilisez une chaîne avec des sauts de ligne comme exemple.

                          s = 'Alice\nBob\nCharlie'
                          print(s)
                          # Alice
                          # Bob
                          # Charlie
                          

                          Pour plus d'informations sur les sauts de ligne en Python, consultez l'article suivant.

                            Supprimer une partie de la chaîne dans chaque ligne

                            Lors de la suppression d'une partie de chaque ligne d'une chaîne contenant des retours à la ligne, les méthodes qui agissent sur la chaîne entière, telles que replace() , peut être utilisé sans souci particulier.

                            print(s.replace('li', ''))
                            # Ace
                            # Bob
                            # Chare
                            

                            D'autre part, des méthodes telles que strip() sont traités pour le début et la fin de la chaîne entière comme suit.

                            print(s.strip('bce'))
                            # Alice
                            # Bob
                            # Charli
                            

                            Les tranches sont également traitées pour la chaîne entière.

                            print(s[2:-2])
                            # ice
                            # Bob
                            # Charl
                            

                            Pour traiter chaque ligne individuellement, divisez d'abord chaque ligne avec splitlines() .

                              l_s = s.splitlines()
                              print(l_s)
                              # ['Alice', 'Bob', 'Charlie']
                              

                              Utilisez la compréhension de liste pour cette liste.

                              l_s_strip = [line.strip('bce') for line in l_s]
                              print(l_s_strip)
                              # ['Ali', 'Bo', 'Charli']
                              

                              Concaténer les en une seule chaîne avec join() .

                                s_line_strip = '\n'.join(l_s_strip)
                                print(s_line_strip)
                                # Ali
                                # Bo
                                # Charli
                                

                                Vous pouvez même les écrire tous ensemble. L'exemple suivant applique une tranche à chaque ligne.

                                print('\n'.join([line[:2] for line in s.splitlines()]))
                                # Al
                                # Bo
                                # Ch
                                

                                Supprimer des lignes selon condition

                                Pour supprimer les lignes qui remplissent ou non une condition, ajoutez une condition à la compréhension de la liste.

                                  l_remove = [line for line in s.splitlines() if not line.startswith('B')]
                                  print(l_remove)
                                  # ['Alice', 'Charlie']
                                  

                                  Après cela, concaténez-les en une seule chaîne avec join() .

                                  s_line_remove = '\n'.join(l_remove)
                                  print(s_line_remove)
                                  # Alice
                                  # Charlie
                                  

                                  Vous pouvez les écrire tous ensemble.

                                  print('\n'.join([line for line in s.splitlines() if 'li' in line]))
                                  # Alice
                                  # Charlie
                                  

                                  Consultez l'article suivant pour les conditions sur les chaînes.