¿Por qué 3 barras diagonales inversas equivalen a 4 en una cadena de Python?

¿Podrías decirme por qué '?\\\?'=='?\\\\?'da True? Eso me vuelve loco y no encuentro una respuesta razonable ...

>>> list('?\\\?')
['?', '\\', '\\', '?']
>>> list('?\\\\?')
['?', '\\', '\\', '?']

Básicamente, porque Python es un poco indulgente en el procesamiento de barra invertida. Citando de https://docs.python.org/2.0/ref/strings.html :

A diferencia del Estándar C, todas las secuencias de escape no reconocidas se dejan en la cadena sin cambios, es decir, la barra invertida se deja en la cadena .

(Énfasis en el original)

Por lo tanto, en Python, no es que tres barras invertidas sean iguales a cuatro, es que cuando sigue una barra invertida con un carácter como ?, los dos juntos aparecen como dos caracteres, porque \?no es una secuencia de escape reconocida.

Esto se debe a que la barra invertida actúa como un carácter de escape para los caracteres que le siguen inmediatamente, si la combinación representa una secuencia de escape válida. La docena de secuencias de escape se enumeran aquí . Incluyen los obvios como nueva línea \n, tabulación horizontal \t, retorno de carro \ry otros más oscuros como caracteres Unicode con nombre que utilizan \N{...}, por ejemplo, \N{WAVY DASH}que representa un carácter Unicode \u3030. Sin embargo, el punto clave es que si no se conoce la secuencia de escape, la secuencia de caracteres se deja en la cadena como está.

Parte del problema también podría ser que la salida del intérprete de Python lo engañe. Esto se debe a que las barras invertidas se eliminan cuando se muestran. Sin embargo, si imprime esas cadenas, verá desaparecer las barras invertidas adicionales.

>>> '?\\\?'
'?\\\\?'
>>> print('?\\\?')
?\\?
>>> '?\\\?' == '?\\?'    # I don't know why you think this is True???
False
>>> '?\\\?' == r'?\\?'   # but if you use a raw string for '?\\?'
True
>>> '?\\\\?' == '?\\\?'  # this is the same string... see below
True

Para sus ejemplos específicos, en el primer caso '?\\\?', el primero \escapa de la segunda barra invertida dejando una sola barra invertida, pero la tercera barra invertida permanece como una barra invertida porque \?no es una secuencia de escape válida. Por lo tanto, la cadena resultante es ?\\?.

Para el segundo caso '?\\\\?', la primera barra invertida escapa al segundo y la tercera barra invertida escapa al cuarto, lo que da como resultado la cadena ?\\?.

Por eso, tres barras diagonales inversas son lo mismo que cuatro:

>>> '?\\\?' == '?\\\\?'
True

Si desea crear una cadena con 3 barras invertidas, puede escapar de cada barra invertida:

>>> '?\\\\\\?'
'?\\\\\\?'
>>> print('?\\\\\\?')
?\\\?

o puede encontrar cadenas "crudas" más comprensibles:

>>> r'?\\\?'
'?\\\\\\?'
>>> print(r'?\\\?')
?\\\?

Esto convierte el procesamiento de la secuencia de escape para el literal de cadena. Consulte String Literals para obtener más detalles.

Debido a que \xen una cadena de caracteres, cuando xno es uno de los caracteres especiales como backslashable n, r, t, 0, etc, se evalúa como una cadena con una barra invertida y luego una x.

>>> '\?'
'\\?'

Desde la página de análisis léxico de Python en literales de cadena en: https://docs.python.org/2/reference/lexical_analysis.html

Hay una tabla que enumera todas las secuencias de escape reconocidas.

\\ es una secuencia de escape que es === \

\? no es una secuencia de escape y es === \?

entonces '\\\\' es '\\' seguido de '\\' que es '\\' (dos escapados \)

y '\\\' es '\\' seguido de '\' que también es '\\' (uno escapado \ y uno sin procesar \)

Además, debe tenerse en cuenta que Python no distingue entre comillas simples y dobles que rodean un literal de cadena, a diferencia de otros lenguajes.

Entonces, 'Cadena' y "Cadena" son exactamente lo mismo en Python, no afectan la interpretación de las secuencias de escape.

La respuesta de mhawke lo cubre bastante, solo quiero reformularlo de una forma más concisa y con ejemplos mínimos que ilustren este comportamiento.

Supongo que una cosa para agregar es que el procesamiento de escape se mueve de izquierda a derecha, de modo que \nprimero encuentra la barra invertida y luego busca un personaje para escapar, luego lo encuentra ny lo escapa; \\nencuentra la primera barra invertida, busca la segunda y la escapa, luego la encuentra ny la ve como una n literal; \?encuentra barra invertida y busca un carácter para escapar, encuentra ?que no se puede escapar y, por lo tanto, trata \como una barra invertida literal.

Como señaló mhawke, la clave aquí es que el intérprete interactivo escapa de la barra invertida cuando muestra una cadena. Supongo que la razón de esto es asegurarse de que las cadenas de texto copiadas del intérprete al editor de código sean cadenas de Python válidas. Sin embargo, en este caso, esta concesión por conveniencia genera confusión.

>>> print('\?') # \? is not a valid escape code so backslash is left as-is
\?
>>> print('\\?') # \\ is a valid escape code, resulting in a single backslash
'\?'

>>> '\?' # same as first example except that interactive interpreter escapes the backslash
\\?
>>> '\\?' # same as second example, backslash is again escaped
\\?