I'm trying to discard lines that include the string "\sout{" (which is TeX, for
those who are curious. I have tried:
if not re.search("\sout{", line):
if not re.search("\sout\{", line):
if not re.search("\\sout{", line):
if not re.search("\\sout\{", line):

But the lines with that string keep coming through. What is the right syntax to
properly escape the backslash and the left curly bracket?

--
Michael F. Stemper
No animals were harmed in the composition of this message.

"Michael F. Stemper" <michael.stemper@gmail.com> wrote or quoted:
> if not re.search("\\sout\{", line):

So, if you're not down to slap an "r" before your string literals,
you're going to end up doubling down on every backslash.

Long story short, those double backslashes in your regex?
They'll be quadrupling up in your Python string literal!

main.py

import re

lines = r'''
abcdef
\sout{abcdef
abcdef
abc\sout{def
abcdef
abcdef\sout{
abcdef
'''.strip().split( '\n' )

for line in lines:
product = re.search( "\\\\sout\\{", line )
if not product:
print( line )

stdout

abcdef
abcdef
abcdef
abcdef

On 07/10/2024 08.56, Stefan Ram wrote:
> "Michael F. Stemper" <michael.stemper@gmail.com> wrote or quoted:
>> if not re.search("\\sout\{", line):
>
> So, if you're not down to slap an "r" before your string literals,
> you're going to end up doubling down on every backslash.

Never heard of that before, but it did the trick.

> Long story short, those double backslashes in your regex?
> They'll be quadrupling up in your Python string literal!

> for line in lines:
> product = re.search( "\\\\sout\\{", line )

This also worked.

For now, I'll use the "r" in a cargo-cult fashion, until I decide which
syntax I prefer. (Is there any reason that one or the other is preferable?)

Thanks for your help,
Mike
--
Michael F. Stemper
Economists have correctly predicted seven of the last three recessions.

"Michael F. Stemper" <michael.stemper@gmail.com> wrote or quoted:
>For now, I'll use the "r" in a cargo-cult fashion, until I decide which
>syntax I prefer. (Is there any reason that one or the other is preferable?)

I'd totally go with the r-style notation!

It's got one bummer though - you can't end such a string literal with
a backslash. But hey, no biggie, you could use one of those notations:

main.py

path = r'C:\Windows\example' + '\\'

print( path )

path = r'''
C:\Windows\example\
'''.strip()

print( path )

stdout

C:\Windows\example\
C:\Windows\example\

.

On 2024-10-07, Stefan Ram <ram@zedat.fu-berlin.de> wrote:
> "Michael F. Stemper" <michael.stemper@gmail.com> wrote or quoted:
>>For now, I'll use the "r" in a cargo-cult fashion, until I decide which
>>syntax I prefer. (Is there any reason that one or the other is preferable?)
>
> I'd totally go with the r-style notation!
>
> It's got one bummer though - you can't end such a string literal with
> a backslash. But hey, no biggie, you could use one of those notations:
>
> main.py
>
> path = r'C:\Windows\example' + '\\'
>
> print( path )
>
> path = r'''
> C:\Windows\example\
> '''.strip()
>
> print( path )
>
> stdout
>
> C:\Windows\example\
> C:\Windows\example\
>
> .

.... although of course in this example you should probably do neither of
those things, and instead do:

from pathlib import Path
path = Path(r'C:\Windows\example')

since in a Path the trailing '\' or '/' is unnecessary. Which leaves
very few remaining uses for a raw-string with a trailing '\'...

ram@zedat.fu-berlin.de (Stefan Ram) writes:

> "Michael F. Stemper" <michael.stemper@gmail.com> wrote or quoted:
>
> path = r'C:\Windows\example' + '\\'
>
You could even omit the '+'. Then the concatenation is done at parsing time instead of run time.
--
Pieter van Oostrum <pieter@vanoostrum.org>
www: http://pieter.vanoostrum.org/
PGP key: [8DAE142BE17999C4]

Am Mon, Oct 07, 2024 at 08:35:32AM -0500 schrieb Michael F. Stemper via Python-list:

> I'm trying to discard lines that include the string "\sout{" (which is TeX, for
> those who are curious. I have tried:
> if not re.search("\sout{", line):
> if not re.search("\sout\{", line):
> if not re.search("\\sout{", line):
> if not re.search("\\sout\{", line):

unwanted_tex = '\sout{'
if unwanted_tex not in line: do_something_with_libreoffice()

Karsten
--
GPG 40BE 5B0E C98E 1713 AFA6 5BC0 3BEA AC80 7D4F C89B

On 2024-10-08 19:30, Karsten Hilbert via Python-list wrote:
> Am Mon, Oct 07, 2024 at 08:35:32AM -0500 schrieb Michael F. Stemper via Python-list:
>
>> I'm trying to discard lines that include the string "\sout{" (which is TeX, for
>> those who are curious. I have tried:
>> if not re.search("\sout{", line):
>> if not re.search("\sout\{", line):
>> if not re.search("\\sout{", line):
>> if not re.search("\\sout\{", line):
>
> unwanted_tex = '\sout{'
> if unwanted_tex not in line: do_something_with_libreoffice()
>
That should be:

unwanted_tex = r'\sout{'

or:

unwanted_tex = '\\sout{'

On 2024-10-07 14:35, Michael F. Stemper via Python-list wrote:
> I'm trying to discard lines that include the string "\sout{" (which is TeX, for
> those who are curious. I have tried:
> if not re.search("\sout{", line):
> if not re.search("\sout\{", line):
> if not re.search("\\sout{", line):
> if not re.search("\\sout\{", line):
>
> But the lines with that string keep coming through. What is the right syntax to
> properly escape the backslash and the left curly bracket?
>
String literals use backslash is an escape character, so it needs to be
escaped, or you need to use a "raw" string.

However, regex also uses backslash as an escape character.

That means that a literal backslash in a regex that's in a plain string
literal needs to be doubly-escaped, once for the string literal and
again for the regex.

MRAB <python@mrabarnett.plus.com> wrote or quoted:
>However, regex also uses backslash as an escape character.

TeX also uses the backslash as an escape character:

\chardef \\ = '\\

, the regular expression to search exactly this:

\\chardef \\\\ = '\\\\

, and the Python string literal for that regular expression:

"\\\\chardef \\\\\\\\ = '\\\\\\\\".

. Must be a reason Markdown started to use the backtick!

ram@zedat.fu-berlin.de (Stefan Ram) wrote or quoted:
>"\\\\chardef \\\\\\\\ = '\\\\\\\\".

However, one can rewrite this as follows:

"`chardef `` = '``".replace( "`", "\\"*4 )

. One can also use "repr" to find how to represent something:

main.py

text = input( "What do you want me to represent as a literal? " )
print( repr( text ))

transcript

What do you want me to represent as a literal? \\sout\{
'\\\\sout\\{'

. We can use "escape" and "repr" to find how to represent
a regular expression for a literal text:

main.py

import re

text = input( "Want the literal of an re for what text? " )
print( repr( re.escape( text )))

transcript

Want the literal of an re for what text? \sout{
'\\\\sout\\{'

.

Am Tue, Oct 08, 2024 at 08:07:04PM +0100 schrieb MRAB via Python-list:

> >unwanted_tex = '\sout{'
> >if unwanted_tex not in line: do_something_with_libreoffice()
> >
> That should be:
>
> unwanted_tex = r'\sout{'

Hm.

Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> tex = '\sout{'
>>> tex
'\\sout{'
>>>

Am I missing something ?

Karsten
--
GPG 40BE 5B0E C98E 1713 AFA6 5BC0 3BEA AC80 7D4F C89B

Karsten Hilbert <Karsten.Hilbert@gmx.net> writes:

Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> tex = '\sout{'
>>> tex
'\\sout{'
>>>

Am I missing something ?

You're missing the warning it generates:

> python -E -Wonce
Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> tex = '\sout{'
<stdin>:1: DeprecationWarning: invalid escape sequence '\s'
>>>

On 2024-10-08 21:59, Alan Bawden via Python-list wrote:
> Karsten Hilbert <Karsten.Hilbert@gmx.net> writes:
>
> Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
> Type "help", "copyright", "credits" or "license" for more information.
> >>> tex = '\sout{'
> >>> tex
> '\\sout{'
> >>>
>
> Am I missing something ?
>
> You're missing the warning it generates:
>
> > python -E -Wonce
> Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
> Type "help", "copyright", "credits" or "license" for more information.
> >>> tex = '\sout{'
> <stdin>:1: DeprecationWarning: invalid escape sequence '\s'
> >>>

You got lucky that \s in invalid. If it had been \t you would've got a
tab character.

Historically, Python treated invalid escape sequences as literals, but
it's deprecated now and will become an outright error in the future
(probably) because it often hides a mistake, such as the aforementioned
\t being treated as a tab character when the user expected it to be a
literal backslash followed by letter t. (This can occur within Windows
file paths written in plain string literals.)

On Tue, 08 Oct 2024 19:50:14 +0200, Pieter van Oostrum wrote:

> You could even omit the '+'. Then the concatenation is done at parsing
> time instead of run time.

Surprising how few people know about this. It’s a feature copied from C,
and present in C++. But for some reason Java, JavaScript and PHP dropped
it. Python is one of the few other languages that has it.

Am Tue, Oct 08, 2024 at 04:59:48PM -0400 schrieb Alan Bawden via Python-list:

> Karsten Hilbert <Karsten.Hilbert@gmx.net> writes:
>
> Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
> Type "help", "copyright", "credits" or "license" for more information.
> >>> tex = '\sout{'
> >>> tex
> '\\sout{'
> >>>
>
> Am I missing something ?
>
> You're missing the warning it generates:
>
> <stdin>:1: DeprecationWarning: invalid escape sequence '\s'

I knew it'd be good to ask :-D

Karsten
--
GPG 40BE 5B0E C98E 1713 AFA6 5BC0 3BEA AC80 7D4F C89B

On Mon, 7 Oct 2024 08:35:32 -0500, Michael F. Stemper wrote:

> I'm trying to discard lines that include the string "\sout{" (which is
> TeX, for those who are curious. I have tried:
> if not re.search("\sout{", line): if not re.search("\sout\{", line):
> if not re.search("\\sout{", line): if not re.search("\\sout\{",
> line):
>
> But the lines with that string keep coming through. What is the right
> syntax to properly escape the backslash and the left curly bracket?

$ python
Python 3.12.6 (main, Sep 8 2024, 13:18:56) [GCC 14.2.1 20240805] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import re
>>> s = r"testing \sout{WHADDEVVA}"
>>> re.search(r"\\sout{", s)
<re.Match object; span=(8, 14), match='\\sout{'>

You want a literal backslash, hence, you need to escape everything.

It is not enough to escape the "\s" as "\\s", because that only takes care
of Python's demands for escaping "\". You also need to escape the "\" for
the RegEx as well, or it will read it like it means "\s", which is the
RegEx for a space character and therefore your search doesn't match,
because it reads it like you want to search for " out{".

Therefore, you need to escape it either as per my example, or by using
four "\" and no "r" in front of the first quote, which also works:

>>> re.search("\\\\sout{", s)
<re.Match object; span=(8, 14), match='\\sout{'>

You don't need to escape the curly braces. We call them "seagull wings"
where I live.

--
Gilmeh

Sometimes I simply feel that the whole world is a cigarette and I'm the
only ashtray.

Is there some utility function out there that can be called to show what the
regular expression you typed in will look like by the time it is ready to be
used?

Obviously, life is not that simple as it can go through multiple layers with
each dealing with a layer of backslashes.

But for simple cases, ...

-----Original Message-----
From: Python-list <python-list-bounces+avi.e.gross=gmail.com@python.org> On
Behalf Of Gilmeh Serda via Python-list
Sent: Friday, October 11, 2024 10:44 AM
To: python-list@python.org
Subject: Re: Correct syntax for pathological re.search()

On Mon, 7 Oct 2024 08:35:32 -0500, Michael F. Stemper wrote:

> I'm trying to discard lines that include the string "\sout{" (which is
> TeX, for those who are curious. I have tried:
> if not re.search("\sout{", line): if not re.search("\sout\{", line):
> if not re.search("\\sout{", line): if not re.search("\\sout\{",
> line):
>
> But the lines with that string keep coming through. What is the right
> syntax to properly escape the backslash and the left curly bracket?

$ python
Python 3.12.6 (main, Sep 8 2024, 13:18:56) [GCC 14.2.1 20240805] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import re
>>> s = r"testing \sout{WHADDEVVA}"
>>> re.search(r"\\sout{", s)
<re.Match object; span=(8, 14), match='\\sout{'>

You want a literal backslash, hence, you need to escape everything.

It is not enough to escape the "\s" as "\\s", because that only takes care
of Python's demands for escaping "\". You also need to escape the "\" for
the RegEx as well, or it will read it like it means "\s", which is the
RegEx for a space character and therefore your search doesn't match,
because it reads it like you want to search for " out{".

Therefore, you need to escape it either as per my example, or by using
four "\" and no "r" in front of the first quote, which also works:

>>> re.search("\\\\sout{", s)
<re.Match object; span=(8, 14), match='\\sout{'>

You don't need to escape the curly braces. We call them "seagull wings"
where I live.

--
Gilmeh

Sometimes I simply feel that the whole world is a cigarette and I'm the
only ashtray.
--
https://mail.python.org/mailman/listinfo/python-list

On 2024-10-11 22:13, AVI GROSS via Python-list wrote:
> Is there some utility function out there that can be called to show what the
> regular expression you typed in will look like by the time it is ready to be
> used?
>
> Obviously, life is not that simple as it can go through multiple layers with
> each dealing with a layer of backslashes.
>
> But for simple cases, ...
>
Yes. It's called 'print'. :-)
>
>
> -----Original Message-----
> From: Python-list <python-list-bounces+avi.e.gross=gmail.com@python.org> On
> Behalf Of Gilmeh Serda via Python-list
> Sent: Friday, October 11, 2024 10:44 AM
> To: python-list@python.org
> Subject: Re: Correct syntax for pathological re.search()
>
> On Mon, 7 Oct 2024 08:35:32 -0500, Michael F. Stemper wrote:
>
>> I'm trying to discard lines that include the string "\sout{" (which is
>> TeX, for those who are curious. I have tried:
>> if not re.search("\sout{", line): if not re.search("\sout\{", line):
>> if not re.search("\\sout{", line): if not re.search("\\sout\{",
>> line):
>>
>> But the lines with that string keep coming through. What is the right
>> syntax to properly escape the backslash and the left curly bracket?
>
> $ python
> Python 3.12.6 (main, Sep 8 2024, 13:18:56) [GCC 14.2.1 20240805] on linux
> Type "help", "copyright", "credits" or "license" for more information.
>>>> import re
>>>> s = r"testing \sout{WHADDEVVA}"
>>>> re.search(r"\\sout{", s)
> <re.Match object; span=(8, 14), match='\\sout{'>
>
> You want a literal backslash, hence, you need to escape everything.
>
> It is not enough to escape the "\s" as "\\s", because that only takes care
> of Python's demands for escaping "\". You also need to escape the "\" for
> the RegEx as well, or it will read it like it means "\s", which is the
> RegEx for a space character and therefore your search doesn't match,
> because it reads it like you want to search for " out{".
>
> Therefore, you need to escape it either as per my example, or by using
> four "\" and no "r" in front of the first quote, which also works:
>
>>>> re.search("\\\\sout{", s)
> <re.Match object; span=(8, 14), match='\\sout{'>
>
> You don't need to escape the curly braces. We call them "seagull wings"
> where I live.
>

On 2024-10-11 17:13:07 -0400, AVI GROSS via Python-list wrote:
> Is there some utility function out there that can be called to show what the
> regular expression you typed in will look like by the time it is ready to be
> used?

I assume that by "ready to be used" you mean the compiled form?

No, there doesn't seem to be a way to dump that. You can

p = re.compile("\\\\sout{")
print(p.pattern)

but that just prints the input string, which you could do without
compiling it first.

But - without having looked at the implementation - it's far from clear
that the compiled form would be useful to the user. It's probably some
kind of state machine, and a large table of state transitions isn't very
readable.

There are a number of websites which visualize regular expressions.
Those are probably better for debugging a regular expression than
anything the re module could reasonably produce (although with the
caveat that such a web site would use a different implementation and
therefore might produce different results).

hp

--
_ | Peter J. Holzer | Story must make more sense than reality.
|_|_) | |
| | | hjp@hjp.at | -- Charles Stross, "Creative writing
__/ | http://www.hjp.at/ | challenge!"

"Peter J. Holzer" <hjp-python@hjp.at> wrote or quoted:
>But - without having looked at the implementation - it's far from clear
>that the compiled form would be useful to the user.

So, what he might be getting at with "compiled form" is a
representation that's easy on the eyes for us mere mortals.

You could, for instance, use colors to show the difference between
object and meta characters. In that case, the regex "\**" would
come out as "**", but the first "*" might be navy blue (on a white
background), so just your run-of-the-mill object character, while
the second one would be burgundy, flagging it as a meta character.

So, simplified, that would be something like:

import re
import tkinter as tk
import time

def tokenize_regex( pattern ):
tokens = []
i = 0
while i < len( pattern ):
if pattern[ i ] == '\\':
if i + 1 < len( pattern ):
tokens.append( ( 'escaped', pattern[ i+1: i+2 ]))
i += 2
else:
tokens.append( ('error', 'Incomplete escape sequence' ))
i += 1
elif pattern[i] == '*':
tokens.append( ( 'repetition', '*' ))
i += 1
else:
tokens.append( ( 'plain', pattern[ i ]))
i += 1

return tokens

root = tk.Tk()
root.configure( bg='white' )

regex = r'\**'
result = tokenize_regex( regex )

for token_type, token_value in result:
if token_type == 'plain' or token_type == 'escaped':
tk.Label( root, text=token_value, font=( 'Arial', 40 ), fg='#4070FF', bg='white' ).pack( side='left' )
elif token_type == 'repetition':
tk.Label( root, text=token_value, font=( 'Arial', 40 ), fg='#C02000', bg='white' ).pack( side='left' )

root.mainloop()

.

On 10/12/2024 6:59 AM, Peter J. Holzer via Python-list wrote:
> On 2024-10-11 17:13:07 -0400, AVI GROSS via Python-list wrote:
>> Is there some utility function out there that can be called to show what the
>> regular expression you typed in will look like by the time it is ready to be
>> used?
>
> I assume that by "ready to be used" you mean the compiled form?
>
> No, there doesn't seem to be a way to dump that. You can
>
> p = re.compile("\\\\sout{")
> print(p.pattern)
>
> but that just prints the input string, which you could do without
> compiling it first.

It prints the escaped version, so you can see if you escaped the string
as you intended. In this case, the print will display '\\sout{'. That's
worth something.

>
> But - without having looked at the implementation - it's far from clear
> that the compiled form would be useful to the user. It's probably some
> kind of state machine, and a large table of state transitions isn't very
> readable.
>
> There are a number of websites which visualize regular expressions.
> Those are probably better for debugging a regular expression than
> anything the re module could reasonably produce (although with the
> caveat that such a web site would use a different implementation and
> therefore might produce different results).
>
> hp
>
>

Peter,

Matthew understood what I was hinting at in one way and you in another.

The question asked how to add some power of two backslashes or make other
changes, so the RE functionality sees what you want. The goal is to see what
happens when one or more intermediate evaluations may change the string.

So, a simple print may suffice as a parallel way to force the same
evaluations.

Thomas made his point. And, I am starting to feel like I need to change my
name to something like Luke since this discussion must be gospel.

FYI, I was not planning on posting at all. Time to detach.

-----Original Message-----
From: Python-list <python-list-bounces+avi.e.gross=gmail.com@python.org> On
Behalf Of Peter J. Holzer via Python-list
Sent: Saturday, October 12, 2024 7:00 AM
To: python-list@python.org
Subject: Re: Correct syntax for pathological re.search()

On 2024-10-11 17:13:07 -0400, AVI GROSS via Python-list wrote:
> Is there some utility function out there that can be called to show what
the
> regular expression you typed in will look like by the time it is ready to
be
> used?

I assume that by "ready to be used" you mean the compiled form?

No, there doesn't seem to be a way to dump that. You can

p = re.compile("\\\\sout{")
print(p.pattern)

but that just prints the input string, which you could do without
compiling it first.

But - without having looked at the implementation - it's far from clear
that the compiled form would be useful to the user. It's probably some
kind of state machine, and a large table of state transitions isn't very
readable.

There are a number of websites which visualize regular expressions.
Those are probably better for debugging a regular expression than
anything the re module could reasonably produce (although with the
caveat that such a web site would use a different implementation and
therefore might produce different results).

hp

--
_ | Peter J. Holzer | Story must make more sense than reality.
|_|_) | |
| | | hjp@hjp.at | -- Charles Stross, "Creative writing
__/ | http://www.hjp.at/ | challenge!"

On 10/11/2024 8:37 PM, MRAB via Python-list wrote:
> On 2024-10-11 22:13, AVI GROSS via Python-list wrote:
>> Is there some utility function out there that can be called to show
>> what the
>> regular expression you typed in will look like by the time it is ready
>> to be
>> used?
>>
>> Obviously, life is not that simple as it can go through multiple
>> layers with
>> each dealing with a layer of backslashes.
>>
>> But for simple cases, ...
>>
> Yes. It's called 'print'. :-)

There is section in the Python docs about this backslash subject. It's
titled "The Backslash Plague" in

https://docs.python.org/3/howto/regex.html

You can also inspect the compiled expression to see what string it
received after all the escaping:

>>> import re
>>>
>>> re_string = '\\w+\\\\sub'
>>> re_pattern = re.compile(re_string)
>>>
>>> # Should look as if we had used r'\w+\\sub'
>>> print(re_pattern.pattern)
\w+\\sub

>> -----Original Message-----
>> From: Python-list <python-list-
>> bounces+avi.e.gross=gmail.com@python.org> On
>> Behalf Of Gilmeh Serda via Python-list
>> Sent: Friday, October 11, 2024 10:44 AM
>> To: python-list@python.org
>> Subject: Re: Correct syntax for pathological re.search()
>>
>> On Mon, 7 Oct 2024 08:35:32 -0500, Michael F. Stemper wrote:
>>
>>> I'm trying to discard lines that include the string "\sout{" (which is
>>> TeX, for those who are curious. I have tried:
>>>    if not re.search("\sout{", line): if not re.search("\sout\{", line):
>>>    if not re.search("\\sout{", line): if not re.search("\\sout\{",
>>>    line):
>>>
>>> But the lines with that string keep coming through. What is the right
>>> syntax to properly escape the backslash and the left curly bracket?
>>
>> $ python
>> Python 3.12.6 (main, Sep  8 2024, 13:18:56) [GCC 14.2.1 20240805] on
>> linux
>> Type "help", "copyright", "credits" or "license" for more information.
>>>>> import re
>>>>> s = r"testing \sout{WHADDEVVA}"
>>>>> re.search(r"\\sout{", s)
>> <re.Match object; span=(8, 14), match='\\sout{'>
>>
>> You want a literal backslash, hence, you need to escape everything.
>>
>> It is not enough to escape the "\s" as "\\s", because that only takes
>> care
>> of Python's demands for escaping "\". You also need to escape the "\" for
>> the RegEx as well, or it will read it like it means "\s", which is the
>> RegEx for a space character and therefore your search doesn't match,
>> because it reads it like you want to search for " out{".
>>
>> Therefore, you need to escape it either as per my example, or by using
>> four "\" and no "r" in front of the first quote, which also works:
>>
>>>>> re.search("\\\\sout{", s)
>> <re.Match object; span=(8, 14), match='\\sout{'>
>>
>> You don't need to escape the curly braces. We call them "seagull wings"
>> where I live.
>>
>

Gilmeh Serda <gilmeh.serda@nothing.here.invalid> wrote or quoted:
>You don't need to escape the curly braces.

Here's the 411 on some gnarly regex characters:

.. matches any single character, except when it hits a new line
^ kicks things off at the start of the sequence
$ wraps it up at the end
* goes zero to infinity
+ one or more times
? maybe once, maybe not
{ starts a specific count, like {2} or {2,3}
} ends such a count
| either this or that
\ flips the script on the next character's meaning
( drops in on a group
) bails out of the group
[ paddles out to a character class
] rides the character class to shore

.