Comment remplacer les occurrences d'un caractère avec une seule instance de ce personnage en python

Je veux remplacer les instances répétées de la "*" caractère dans une chaîne, avec une seule instance de "*". Par exemple, si la chaîne est "***abc**de*fg******h", je veux qu'il se converti à "*abc*de*fg*h".

Je suis assez nouveau à python (et de la programmation en général) et essayé d'utiliser des expressions régulières et de la corde.replace() comme:

import re    
pattern = "***abc**de*fg******h"
pattern.replace("*"\*, "*")

où \* est censé remplacer toutes les occurrences du caractère"*". Mais j'ai eu: SyntaxError: unexpected caractère après caractère de continuation de ligne.

J'ai aussi essayé de le manipuler avec une boucle for comme:

def convertString(pattern):
for i in range(len(pattern)-1):
    if(pattern[i] == pattern[i+1]):
        pattern2 = pattern[i]
return pattern2

mais cela a l'erreur où il imprime seulement les "*" les car pattern2 = pattern[i] constamment redéfinit ce qu'pattern2 est...

Toute aide serait appréciée.

OriginalL'auteur NSchrading | 2010-10-07

python string

19

Le naïf façon de faire ce genre de chose avec re est
```
re.sub('\*+', '*', text)
```
Qui remplace les pistes de 1 ou plusieurs astérisques avec un astérisque. Pour les courses de exactement un astérisque, qui est en cours d'exécution très dur juste pour rester immobile. Beaucoup mieux est de remplacer les pistes de deux ou plus de DEUX astérisques par un astérisque:
```
re.sub('\*\*+', '*', text)
```
Cela peut être bien la peine de le faire:
```
\python27\python -mtimeit -s"t='a*'*100;import re" "re.sub('\*+', '*', t)"
10000 loops, best of 3: 73.2 usec per loop

\python27\python -mtimeit -s"t='a*'*100;import re" "re.sub('\*\*+', '*', t)"
100000 loops, best of 3: 8.9 usec per loop
```
Noter que les ré.sous renverra une référence à la chaîne d'entrée, si elle n'a pas trouvé de correspondances, d'économiser plus de l'usure sur votre ordinateur, au lieu d'une toute nouvelle chaîne.

+1 C'est une bonne astuce. Bien que, pour une moyenne Joe qui pourrait ne pas être en faisant cela des milliers de fois par seconde, la différence n'est pas très dérangeant. L'ancien victoires sur la lisibilité. Donc, je vous suggère, ne pas aveuglément utiliser celui-ci.
Pas sûr au sujet de la lisibilité ... une fois JAvg comprend \X, le saut à \X\X semble minuscule à moi. Peut-être \X{2,} serait mieux? J'espère que JAvg ne rien faire à l'aveuglette. Si la sortie exigence changé à "trouver toutes les occurrences de la répétition des astérisques", vous me plais à penser que l'expression rationnelle a été changé à partir de 1+ à 2+.

OriginalL'auteur John Machin

un non regex façon

def squeeze(char,s):
    while char*2 in s:
        s=s.replace(char*2,char)
    return s
print squeeze("*" , "AB***abc**def**AA***k")

OriginalL'auteur ghostdog74

4

Je suggérerais à l'aide de la module re sous-fonction:
```
import re

result = re.sub("\*+", "*", "***abc**de*fg******h")
```
Je recommande fortement la lecture par le biais de l'article à propos de RE et de bonnes pratiques. Ils peuvent être difficile si vous n'êtes pas familier avec eux. Dans la pratique, à l'aide de matières de chaînes de caractères est une bonne idée.

Merci beaucoup, cela fonctionne bien, je vais lire l'article sur la reprise de comprendre ce qui se passe exactement avec le "\+" du code. Je ne savais pas qu'on pouvait utiliser plusieurs symboles en conjonction les uns avec les autres. J'ai pensé que vous ne pourriez utiliser "+" ou "*" par exemple.
Dans "\\*+", je suis d'échapper le caractère * parce que c'est une re symbole. J'ai donc correspondre à un littéral caractère*, et le + signifie un ou plusieurs.

OriginalL'auteur JoshD

Vous avez écrit:

pattern.replace("*"\*, "*")

Vous dire:

pattern.replace("\**", "*")
#                ^^^^

Vous vraiment que cela signifiait:

pattern_after_substitution= re.sub(r"\*+", "*", pattern)

qui fait ce que vous vouliez.

OriginalL'auteur tzot

1

Bien les expressions régulières sage, je ferais exactement comme JoshD a suggéré. Mais une amélioration ici.

Utilisation -
```
regex  = re.compile('\*+')
result = re.sub(regex, "*", string)
```
Ce serait essentiellement le cache de votre regex. Donc d'un usage ultérieur de cette dans une boucle rendrait votre regex opérations rapides.

C'est une optimisation prématurée. Python caches utilisées récemment compilé regexes de toute façon.

OriginalL'auteur Srikar Appalaraju
0
```
re.sub('\*+', '*', pattern)
```
Qui va le faire.

OriginalL'auteur Ruel
0

sans regexp vous pouvez utiliser générale de répéter l'élément de retrait avec vérification des '*':
```
source = "***abc**dee*fg******h"
target = ''.join(c for c,n in zip(source, source[1:]+' ') if  c+n != '**')
print target
```
OriginalL'auteur Tony Veijalainen

Permet de supposer dans ce but de cet exemple, votre personnage est un espace.

Vous pouvez également le faire de cette façon:

while True:
    if "  " in pattern: # if two spaces are in the variable pattern
        pattern = pattern.replace("  ", " ") # replace two spaces with one
    else: # otherwise
        break # break from the infinite while loop

Ce:

File Type                       : Win32 EXE
File Type Extension             : exe
MIME Type                       : application/octet-stream
Machine Type                    : Intel 386 or later, and compatibles
Time Stamp                      : 2017:04:24 09:55:04-04:00

Devient:

File Type : Win32 EXE
File Type Extension : exe
MIME Type : application/octet-stream
Machine Type : Intel 386 or later, and compatibles
Time Stamp : 2017:04:24 09:55:04-04:00

Je trouve que c'est un peu plus facile que d'avoir à nettoyer avec le module re, qui peut devenir un peu ennuyeux parfois (je pense).

De l'espoir qui a été utile.

OriginalL'auteur copeland3300

0

Cela fonctionne pour n'importe quel nombre de tentatives d'astérisques, bien que vous devrez peut-être remplacer ce caractère par une autre chaîne que vous savez être unique tout au long de la chaîne.
```
    string = "begin*************end"

    string.replace("**", "~*").replace("*~", "").replace("~*", "*").replace("**", "*")
```
Je crois regex approches sont généralement plus gourmand en ressources que cela.

OriginalL'auteur Brian from Chicago
0

J'ai chronométré toutes les méthodes dans le courant des réponses (avec Python 3.7.2, macOS High Sierra).

b() était le meilleur dans l'ensemble, c() était meilleur lorsqu'aucune correspondance n'est fait.
```
def b(text):
    re.sub(r"\*\*+", "*", text)

# aka squeeze()
def c(text):
    while "*" * 2 in text:
        text = text.replace("*" * 2, "*")
    return text
```
Entrée 1, pas de répétitions:
'a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*'
- a) 10000 boucles, au meilleur des 5: 24.5 usec par boucle
- b) 100000 boucles, au meilleur des 5: 3.17 usec par boucle
- c) 500000 boucles, au meilleur des 5: 508 nsec par boucle
- d) 10000 boucles, au meilleur des 5: de 25,4 usec par boucle
- e) 5000 boucles, au meilleur des 5: 44.7 usec par boucle
- f) 500000 boucles, au meilleur des 5: 522 nsec par boucle
Entrée 2, avec des répétitions:
'a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*****************************************************************************************************a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*'
- a) 5000 boucles, au meilleur des 5: 46.2 usec par boucle
- b) 50000 boucles, au meilleur des 5: 5.21 usec par boucle
- c) 20000 boucles, au meilleur des 5: 13.4 usec par boucle
- d) 5000 boucles, au meilleur des 5: 47.4 usec par boucle
- e) 2000 boucles, au meilleur des 5: 103 usec par boucle
- f) 20000 boucles, au meilleur des 5: 13.1 usec par boucle
Les méthodes:
```
#!/usr/bin/env python
# encoding: utf-8
"""
See which function variants are fastest. Run like:
python -mtimeit -s"import time_functions;t='a*'*100" "time_functions.a(t)"
python -mtimeit -s"import time_functions;t='a*'*100" "time_functions.b(t)"
etc.
"""
import re


def a(text):
    return re.sub(r"\*+", "*", text)


def b(text):
    re.sub(r"\*\*+", "*", text)


# aka squeeze()
def c(text):
    while "*" * 2 in text:
        text = text.replace("*" * 2, "*")
    return text


regex = re.compile(r"\*+")


# like a() but with (premature) optimisation
def d(text):
    return re.sub(regex, "*", text)


def e(text):
    return "".join(c for c, n in zip(text, text[1:] + " ") if c + n != "**")


def f(text):
    while True:
        if "**" in text:  # if two stars are in the variable pattern
            text = text.replace("**", "*")  # replace two stars with one
        else:  # otherwise
            break  # break from the infinite while loop
    return text
```
OriginalL'auteur Hugo

Vous devez vous connecter pour publier un commentaire.