de php para el pitón

Question

php tiene la función strtr:

strtr('aa-bb-cc', array('aa' => 'bbz', 'bb' => 'x', 'cc' => 'y')); 
# bbz-x-y 

Sustituye claves de diccionario en una cadena con los valores correspondientes y (importante) no reemplaza ya reemplazado cuerdas. Un intento ingenuo para escribir la misma en Python:

def strtr(strng, replace): 
    for s, r in replace.items(): 
     strng = strng.replace(s, r) 
    return strng 

strtr('aa-bb-cc', {'aa': 'bbz', 'bb': 'x', 'cc': 'y'}) 

vuelve xz-x-y que no queremos es (bb obtuve reemplazado de nuevo). ¿Cómo cambiar la función anterior para que se comporte como su contraparte php?

(Preferiría una respuesta sin expresiones regulares, si es posible).

Upd: algunas buenas respuestas aquí. Me ellos cronometrados y se encontró que para las cadenas cortas versión de Gumbo parece ser el más rápido, en cadenas más largas el ganador es la solución re:

# 'aa-bb-cc' 
0.0258 strtr_thg 
0.0274 strtr_gumbo 
0.0447 strtr_kojiro 
0.0701 strtr_aix 

# 'aa-bb-cc'*10 
0.1474 strtr_aix 
0.2261 strtr_thg 
0.2366 strtr_gumbo 
0.3226 strtr_kojiro 

Mi propia versión (que está ligeramente optimizado Gumbo):

def strtr(strng, replace): 
    buf, i = [], 0 
    while i < len(strng): 
     for s, r in replace.items(): 
      if strng[i:len(s)+i] == s: 
       buf.append(r) 
       i += len(s) 
       break 
     else: 
      buf.append(strng[i]) 
      i += 1 
    return ''.join(buf) 

códigos y tiempos completos: https://gist.github.com/2889181

Answer 1

Aquí es un algoritmo ingenuo:

utilizar un índice de caminar por la cadena de caracteres original de carácter y comprobar para cada índice si una de las cadenas de búsqueda es igual a la cadena a partir del índice actual sobre. Si se encuentra una coincidencia, inserte el reemplazo en un búfer y proceda con el índice por la longitud de la secuencia coincidente. Si no se encuentra ninguna coincidencia, proceda con el índice en uno. Al final, concatene las cadenas en el buffer a una sola cadena.

def strtr(strng, replace): 
    buffer = [] 
    i, n = 0, len(strng) 
    while i < n: 
     match = False 
     for s, r in replace.items(): 
      if strng[i:len(s)+i] == s: 
       buffer.append(r) 
       i = i + len(s) 
       match = True 
       break 
     if not match: 
      buffer.append(strng[i]) 
      i = i + 1 
    return ''.join(buffer) 

Answer 2

str.translate es el equivalente, pero sólo se puede asignar a un solo carácter.

Answer 3

El siguiente utiliza expresiones regulares para hacerlo:

import re 

def strtr(s, repl): 
    pattern = '|'.join(map(re.escape, sorted(repl, key=len, reverse=True))) 
    return re.sub(pattern, lambda m: repl[m.group()], s) 

print(strtr('aa-bb-cc', {'aa': 'bbz', 'bb': 'x', 'cc': 'y'})) 

Al igual que la versión del PHP, esto da preferencia a los partidos más largos.

Answer 4

def strtr(strng, replace): 
    if replace and strng: 
     s, r = replace.popitem() 
     return r.join(strtr(subs, dict(replace)) for subs in strng.split(s)) 
    return strng 

j=strtr('aa-bb-cc', {'aa': 'bbz', 'bb': 'x', 'cc': 'y'}) 
assert j=='bbz-x-y', j