문자열에서 여러 문자를 교체하는 최상의 방법은 무엇인가요?

다음과 같이 일부 문자를 대체해야합니다 : & ➔ \&, # ➔ \#, ...

제가 다음과 같이 코딩했는데, 더 좋은 방법이 있을 것 같습니다. 힌트 좀 주실 수 있나요?

strs = strs.replace('&', '\&')

strs = strs.replace('#', '\#')

...

답변 1

두 문자 바꾸기

나는 현재 답변들의 모든 방법들과 한 가지 추가 방법을 모두 시간 측정했습니다.

입력 문자열이 # $$ # @$ ^ # $ &이고 &-> \& 및 #-> \ #로 대체하는 경우, 가장 빠른 방법은 다음과 같이 대체를 연결하는 것이었습니다 : #$ * $ ** ^^ $&.

각 기능에 대한 시간:

a) 3회 중 가장 좋은 결과 1000000 개의 루프, 1.47 μs 당 루프입니다.

b) 1000000 번 반복, 3회 중 최고 값: 1.51 마이크로초당 반복

c) 3번 중 가장 좋은 결과: 100000회 반복하여 평균 12.3μs 소요됨

d) 3회 중 최상의 결과, 100,000번 반복: 평균 12 마이크로초 per loop

e) 3 번 중 가장 좋았던 100000 회 반복: 한 회당 3.27 μs

f) 3회 중 가장 좋은 결과: 1000000 회 반복, 루프당 0.817 마이크로초

g) 3회 중 최고값, 100000회 루프: 루프당 3.64 μs

h) 1000000번 반복, 3회 중 최상: 0.927 마이크로초/반복

i) 1000000번 루프, 3회 중 최고: 루프당 0.814 μs

여기 기능들이 있습니다.

def a(text):

chars = &#

for c in chars:

text = text.replace(c, \\ + c)

def b(text):

for ch in ['&','#']:

if ch in text:

text = text.replace(ch,\\+ch)

import re

def c(text):

rx = re.compile('([&#])')

text = rx.sub(r'\\\1', text)

RX = re.compile('([&#])')

def d(text):

text = RX.sub(r'\\\1', text)

def mk_esc(esc_chars):

return lambda s: ''.join(['\\' + c if c in esc_chars else c for c in s])

esc = mk_esc('&#')

def e(text):

esc(text)

def f(text):

text = text.replace('&', '\&').replace('#', '\#')

def g(text):

replacements = {&: \&, #: \#}

text = .join([replacements.get(c, c) for c in text])

def h(text):

text = text.replace('&', r'\&')

text = text.replace('#', r'\#')

def i(text):

text = text.replace('&', r'\&').replace('#', r'\#')

이렇게 시간을 측정합니다:

python -mtimeit -simport time_functions time_functions.a('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.b('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.c('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.d('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.e('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.f('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.g('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.h('abc&def#ghi')

python -mtimeit -simport time_functions time_functions.i('abc&def#ghi')

17개의 문자를 교체합니다.

이와 같지만 더 많은 이스케이프 문자 (\`*_{}>#+-.!$)를 사용하여 동일한 작업을 수행하는 유사한 코드가 있습니다.

def a(text):

chars = \\`*_{}[]()>#+-.!$

for c in chars:

text = text.replace(c, \\ + c)

def b(text):

for ch in ['\\','`','*','_','{','}','[',']','(',')','>','#','+','-','.','!','$','\'']:

if ch in text:

text = text.replace(ch,\\+ch)

import re

def c(text):

rx = re.compile('([&#])')

text = rx.sub(r'\\\1', text)

RX = re.compile('([\\`*_{}[]()>#+-.!$])')

def d(text):

text = RX.sub(r'\\\1', text)

def mk_esc(esc_chars):

return lambda s: ''.join(['\\' + c if c in esc_chars else c for c in s])

esc = mk_esc('\\`*_{}[]()>#+-.!$')

def e(text):

esc(text)

def f(text):

text = text.replace('\\', '\\\\').replace('`', '\`').replace('*', '\*').replace('_', '\_').replace('{', '\{').replace('}', '\}').replace('[', '\[').replace(']', '\]').replace('(', '\(').replace(')', '\)').replace('>', '\>').replace('#', '\#').replace('+', '\+').replace('-', '\-').replace('.', '\.').replace('!', '\!').replace('$', '\$')

def g(text):

replacements = {

\\: \\\\,

`: \`,

*: \*,

_: \_,

{: \{,

}: \},

[: \[,

]: \],

(: \(,

): \),

>: \>,

#: \#,

+: \+,

-: \-,

.: \.,

!: \!,

$: \$,

}

text = .join([replacements.get(c, c) for c in text])

def h(text):

text = text.replace('\\', r'\\')

text = text.replace('`', r'\`')

text = text.replace('*', r'\*')

text = text.replace('_', r'\_')

text = text.replace('{', r'\{')

text = text.replace('}', r'\}')

text = text.replace('[', r'\[')

text = text.replace(']', r'\]')

text = text.replace('(', r'\(')

text = text.replace(')', r'\)')

text = text.replace('>', r'\>')

text = text.replace('#', r'\#')

text = text.replace('+', r'\+')

text = text.replace('-', r'\-')

text = text.replace('.', r'\.')

text = text.replace('!', r'\!')

text = text.replace('$', r'\$')

def i(text):

text = text.replace('\\', r'\\').replace('`', r'\`').replace('*', r'\*').replace('_', r'\_').replace('{', r'\{').replace('}', r'\}').replace('[', r'\[').replace(']', r'\]').replace('(', r'\(').replace(')', r'\)').replace('>', r'\>').replace('#', r'\#').replace('+', r'\+').replace('-', r'\-').replace('.', r'\.').replace('!', r'\!').replace('$', r'\$')

같은 입력 문자열 abc&def#ghi에 대한 결과는 다음과 같습니다.

a) 3번 중 최고, 100000번 반복: 반복당 6.72 마이크로초

b) 3회 중 최상의 결과: 100000회 반복에 대해 1회당 2.64 마이크로초

c) 3회 중 가장 좋은 성능: 루프 10만 회 당 11.9 마이크로초

d) 3회 중 최상의 결과: 100000회 반복 시 평균 4.92 마이크로초

e) 3회 중 최고의 100000 반복: 반복당 2.96 μs

f) 3회 중 최고의 100,000번 반복: 루프 당 4.29 마이크로초

g) 100000번 반복, 3회 중 최고 결과: 반복당 4.68 마이크로초

h) 100000번 반복, 3회 중 최적: 1회당 4.73 마이크로초

i) 3회 중 최고 100000 루프: 루프당 4.24 마이크로초

그리고 더 긴 입력 문자열로 ( ## *Something* and [another] thing in a longer sentence with {more} things to replace$ ):

a) 3회 중 가장 좋은 결과: 100000회 반복에 대한 루프당 7.59 마이크로초

b) 3번 중 최고 100000회 반복: 1회 당 6.54 μs

c) 3회 중 가장 우수한 결과: 루프당 16.9 마이크로초, 100000회 루프

d) 3회 중 최상의 결과, 100000번 반복: 1회당 7.29 마이크로초

e) 3회 중 최상의 실행 결과로 100000회 반복 소요 시간은 12.2 μs입니다.

f) 3회 중 가장 우수한 결과: 루프당 5.38 μs, 100,000회 루프 실행.

g) 3번 중 가장 좋은 결과: 10000번 반복해서 1회당 21.7 μs

h) 3회 중 가장 좋은 결과, 100,000 회 반복: 반복당 5.7 마이크로초

i) 3회 중 최고 기록인 100,000회 반복: 1회당 5.13 μs

두 가지의 변형을 추가하는 것:

def ab(text):

for ch in ['\\','`','*','_','{','}','[',']','(',')','>','#','+','-','.','!','$','\'']:

text = text.replace(ch,\\+ch)

def ba(text):

chars = \\`*_{}[]()>#+-.!$

for c in chars:

if c in text:

text = text.replace(c, \\ + c)

짧은 입력으로는:

100000 번 반복, 3회 중 최고: 7.05 μs/루프

바) 3회 중 가장 좋은 결과로 100000루프를 수행하여 루프 당 2.4 μs 소요됩니다.

두 가지 방법으로 번역하실 수 있습니다. 첫 번째는 더 긴 입력이 있을 때로 번역하는 것이고, 두 번째는 긴 입력과 함께로 번역하는 것입니다. 더 자연스러운 번역을 원한다면 문맥을 고려한 적절한 번역을 선택하시면 됩니다.

ab) 100000번 반복, 3회 중 최고: 루프 당 7.71 마이크로초

ba) 3번 시행 중 최적의 결과: 1회당 6.08 μs 소요되는 100,000번 순회.

그래서 가독성과 속도를 위해 ba을 사용할 것입니다.

부록

댓글에서 해킹에 의해 자극받은 것에 보답하여, ab와 ba의 차이점 중 하나는 if c in text: 검사입니다. 두 가지 더 많은 변형에 대해 테스트해 보겠습니다.

def ab_with_check(text):

for ch in ['\\','`','*','_','{','}','[',']','(',')','>','#','+','-','.','!','$','\'']:

if ch in text:

text = text.replace(ch,\\+ch)

def ba_without_check(text):

chars = \\`*_{}[]()>#+-.!$

for c in chars:

text = text.replace(c, \\ + c)

이전 세트와 다른 기계에서 Python 2.7.14 및 3.6.3에서 반복되는 μs 시간으로, 직접 비교할 수 없습니다.

╭────────────╥──────┬───────────────┬──────┬──────────────────╮

│ Py, input ║ ab │ ab_with_check │ ba │ ba_without_check │

╞════════════╬══════╪═══════════════╪══════╪══════════════════╡

│ Py2, short ║ 8.81 │ 4.22 │ 3.45 │ 8.01 │

│ Py3, short ║ 5.54 │ 1.34 │ 1.46 │ 5.34 │

├────────────╫──────┼───────────────┼──────┼──────────────────┤

│ Py2, long ║ 9.3 │ 7.15 │ 6.85 │ 8.55 │

│ Py3, long ║ 7.43 │ 4.38 │ 4.41 │ 7.02 │

└────────────╨──────┴───────────────┴──────┴──────────────────┘

우리는 결론을 내릴 수 있다.

체크가 있는 사람들은 체크가 없는 사람들보다 최대 4배 더 빠릅니다.

ab_with_check은 Python 3에서 약간 선두에 있지만, 검사와 함께한 ba는 Python 2에서 더 큰 선두를 보입니다.

그러나 이곳에서 가장 큰 교훈은 Python 3가 Python 2보다 3배 더 빠르다는 것입니다! Python 3의 가장 느린 것과 Python 2의 가장 빠른 것 사이에 큰 차이가 없습니다!

답변 2

문자열에서 여러 문자를 바꾸는 가장 좋은 방법은 무엇일까요? 이 글에서는 Python에서 문자열 내 여러 문자를 교체하는 방법을 설명하겠습니다.

Python에서는 문자열 내의 문자를 손쉽게 바꿀 수 있습니다. 여러 방법이 있겠지만, 이 글에서는 문자열 메서드 replace()를 사용해 보겠습니다. 이 방법은 가장 간단하고 유연하며 안정적입니다.

replace() 메서드는 문자열에서 특정 문자를 다른 문자로 바꾸는 역할을 합니다. 이 메서드는 문자열.replace(찾을 문자, 바꿀 문자)와 같이 사용됩니다. 예를 들어, apple 문자열에서 p를 b로 바꾸려면 다음과 같이 작성하면 됩니다.

```python

word = apple

new_word = word.replace(p, b)

print(new_word) # abble

```

이 메서드는 검색 대상 문자열에서 모든 해당 문자를 교체합니다. 그러므로 검색 대상 문자열에 대해 이 메서드를 한 번 호출하면 모든 교체가 완료됩니다. 예를 들어, banana 문자열에서 a를 o로 바꾸려면 다음과 같이 작성하면 됩니다.

```python

word = banana

new_word = word.replace(a, o)

print(new_word) # bonono

```

replace() 메서드를 사용하면 여러 문자를 한 번에 변경할 수도 있습니다. 예를 들어, apple 문자열에서 p를 b로, a를 o로 바꾸려면 다음과 같이 작성하면 됩니다.

```python

word = apple

new_word = word.replace(p, b).replace(a, o)

print(new_word) # obble

```

이와 같이 replace() 메서드를 활용하여 문자열 내 여러 문자를 간단하게 바꿀 수 있습니다. 이 방법을 사용하면 노가다를 최소화할 수 있으며, 코드를 깔끔하게 유지할 수 있습니다.