python：替换/替换字符串中的所有全字匹配

Question

Let's suppose that my string is "#big and #small, #big-red, #big-red-car and #big"

How can I use re.sub(), re.match(), etc. to replace one tag with a word?

For example, all #big s must be changed to BIG, but #big-red and #big-red-car shouldn't be affected.

Answer 1

Let's define your string:

>>> s = "#big and #small, #big-red, #big-red-car and #big"

Now, let's do your replacements:

>>> import re
>>> re.sub(r'#big([.,\s]|$)', r'#BIG\1', s)
'#BIG and #small, #big-red, #big-red-car and #BIG'

The regex #big([.,\\s]|$) will match all #big strings that are followed by a period, a comma, a space, or the end-of-the-line. If there are other characters that you consider to be acceptable after #big , you should add them to the regex.

Alternative

If we want to be a little bit fancier, we can use a look-ahead assertion, (?=...) , to assure that what follows #big is acceptable:

>>> re.sub(r'#big(?=[.,\s]|$)', r'#BIG', s)
'#BIG and #small, #big-red, #big-red-car and #BIG'

A test using periods and commas

To test that this works as desired when #big has "a comma or period after it" , let's create a new string:

>>> s = "#big and #big, #big. #small, #big-red, #big-red-car and #big"

And, let's test it:

>>> re.sub(r'#big(?=[.,\s]|$)', r'#BIG', s)
'#BIG and #BIG, #BIG. #small, #big-red, #big-red-car and #BIG'

Answer 2

This info is a category of one-directional boundary tricks.

Using a Negative look behind/ahead assertion(s),
within the particular direction, it will let BEGIN/END of string match,
yet not allow others to match.

This leads to some interesting scenarios of combining
negative construct's within a class, that cover an endless range
of characters, yet lets you exclude some individual characters within
that range.

Typical constructs to use are the negative classes.

\\D - Non-Digit class
\\S - Non-Whitespace class
\\W - Non-Word class
\\PP - Non-Punctuation property class
\\PL - Non-Letters property class

Since they are used in a negative assertion, the inverse's are actually the
characters being sought.

\\d, \\s, \\w, \\pP, \\pL respectively

The power comes from the fact that they can be combined within
a class for dramatic effects.

If individual characters are added to a class, they are excluded, not allowed.
Effectively, it creates class subtraction .

The rules when creating a class are:

• Classes of characters you want, insert it's negative (ie \\D , \\PP , etc..)
• Individual Characters you don't want, insert as normal (ie \\n , = , etc..)
  This can be used as class subtraction.

Subtraction Example: (?![\\S\\r\\n]) would be a lookahead boundary that requires
only horizontal whitespace, that in some engines, is represented as
the \\h construct.

---

In your example, the boundary's would be something like this.

(?<![\\S\\PP-])#big(?![\\S\\PP-])

Breaking it down

 (?<!            # Boundary - Behind direction
      [\S\PP-]   # Need all whitespace and punctuation, but not the '-'
 )
 \#big
 (?!             # Boundary - Ahead direction
      [\S\PP-]   # Need all whitespace and punctuation, but not the '-'
 )

Each literal character that is added to the class, actually excludes
it from matching.

This is called class subtraction .

---

Test case

Input #big and #small, #big, #big, #big-red, #big-red-car and #big

Output

 **  Grp 0 -  ( pos 0 , len 4 ) 
#big  

 **  Grp 0 -  ( pos 17 , len 4 ) 
#big  

 **  Grp 0 -  ( pos 23 , len 4 ) 
#big  

 **  Grp 0 -  ( pos 56 , len 4 ) 
#big  

Basically, matches these only #big and #small, #big , #big , #big-red, #big-red-car and #big