On 2024-10-12 08:51:57 -0400, Thomas Passin via Python-list wrote:
> 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,

Did you mean the *un*escaped version? Well, yeah, that's what print
does.

> so you can see if you escaped the string as you intended. In this
> case, the print will display '\\sout{'.

print("\\\\sout{")
will do the same.

It seems to me that for any string s which is a valid regular expression
(i.e. re.compile doesn't throw an exception)

assert re.compile(s).pattern == s

holds.

So it doesn't give you anything you didn't already know.

As a trivial example, the regular expressions r"\\sout{" and r"\\sout\{"
are equivalent (the \ before the { is redundant). Yet
re.compile(s).pattern preserves the difference between the two strings.

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 ha scritto:
> As a trivial example, the regular expressions r"\\sout{" and r"\\sout\{"
> are equivalent (the \ before the { is redundant). Yet
> re.compile(s).pattern preserves the difference between the two strings.

Hi,
Allow me to be fussy: r"\\sout{" and r"\\sout\{" are similar but not
equivalent. If you omit the backslash, the parser will have to determine
if the graph is part of regular expression {n, m} and will take more
time. In some online regexs have these results:

r"\\sout{" : 1 match ( 7 steps, 620 μs )

r"\\sout\{" : 1 match ( 7 steps, 360 μs )

On 2024-10-19 00:15:23 +0200, jak via Python-list wrote:
> Peter J. Holzer ha scritto:
> > As a trivial example, the regular expressions r"\\sout{" and r"\\sout\{"
> > are equivalent (the \ before the { is redundant). Yet
> > re.compile(s).pattern preserves the difference between the two strings.
>
> Allow me to be fussy: r"\\sout{" and r"\\sout\{" are similar but not
> equivalent.

They are. Both will match the 6 character string
0005c \ REVERSE SOLIDUS
00073 s LATIN SMALL LETTER S
0006f o LATIN SMALL LETTER O
00075 u LATIN SMALL LETTER U
00074 t LATIN SMALL LETTER T
0007b { LEFT CURLY BRACKET

> If you omit the backslash, the parser will have to determine if the
> graph is part of regular expression {n, m} and will take more time.

Yes, that's the parser. But the result of parsing will be the same:
The string will end in a literal backslash.

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:
>On 2024-10-19 00:15:23 +0200, jak via Python-list wrote:
>>Allow me to be fussy: r"\\sout{" and r"\\sout\{" are similar but not
>>equivalent.
.. . .
>Yes, that's the parser. But the result of parsing will be the same:
>The string will end in a literal backslash.

Functional reqs lay out what your system's got to do, while
non-functional reqs are all about time and other resource
constraints.

When you're crunching through parsing, what pops out is
your functional bread and butter.

But the time it takes to chew through that data?
That's non-functional and implementation-dependent territory.

So, we can say they're functionally equivalent.