Comment puis-je inclure des caractères spéciaux (tabulation, saut de ligne) dans un python doctest chaîne de résultat?

Donné le script python ci:

# dedupe.py
import re

def dedupe_whitespace(s,spacechars='\t '):
    """Merge repeated whitespace characters.
    Example:
    >>> dedupe_whitespace(r"Green\t\tGround")  # doctest: +REPORT_NDIFF
    'Green\tGround'
    """
    for w in spacechars:
        s = re.sub(r"("+w+"+)", w, s)
    return s

La fonction fonctionne comme prévu dans l'interpréteur python:

$ python
>>> import dedupe
>>> dedupe.dedupe_whitespace('Purple\t\tHaze')
'Purple\tHaze'
>>> print dedupe.dedupe_whitespace('Blue\t\tSky')
Blue    Sky

Cependant, la doctest exemple échoue parce que les caractères de tabulation sont converties en espaces avant comparaison à la chaîne de résultat:

>>> import doctest, dedupe
>>> doctest.testmod(dedupe)

donne

Failed example:
    dedupe_whitespace(r"Green           Ground")  #doctest: +REPORT_NDIFF
Differences (ndiff with -expected +actual):
    - 'Green  Ground'
    ?       -
    + 'Green Ground'

Comment puis-je encoder les caractères de tabulation dans un doctest heredoc chaîne, de sorte que le résultat d'un test de comparaison est réalisée de manière appropriée?

InformationsquelleAutor hobs | 2012-01-12

14

J'ai eu à travailler à l'aide de chaîne littérale de notation pour la docstring:
```
def join_with_tab(iterable):
    r"""
    >>> join_with_tab(['1', '2'])
    '1\t2'
    """

    return '\t'.join(iterable)

if __name__ == "__main__":
    import doctest
    doctest.testmod()
```
- Cool. Peut-être que cela fonctionne, car il n'y a aucun caractère de tabulation dans la chaîne littérale qui fait partie d'un doctest déclaration. L'onglet dans la chaîne littérale, la réponse doit être laissé seul. Donc composer mon test de chaîne de caractères qui contient les onglets à l'extérieur de la heredoc citations et utilisation de votre cru heredoc notation pourrait fonctionner!
InformationsquelleAutor wutz

C'est le raw heredoc notation de chaîne de caractères (r""") qui a fait le tour:

# filename: dedupe.py
import re,doctest
def dedupe_whitespace(s,spacechars='\t '):
    r"""Merge repeated whitespace characters.
    Example:
    >>> dedupe_whitespace('Black\t\tGround')  #doctest: +REPORT_NDIFF
    'Black\tGround'
    """
    for w in spacechars:
        s = re.sub(r"("+w+"+)", w, s)
    return s

if __name__ == "__main__":
    doctest.testmod()

InformationsquelleAutor hobs

2

C'est fondamentalement YatharhROCK de réponse, mais un peu plus explicite. Vous pouvez utiliser des chaînes de ou double échappement. Mais pourquoi?

Vous avez besoin de la chaîne de caractères littérale de contenir valide le code Python qui, lorsqu'il est interprété, le code que vous voulez exécuter/test. Ces deux travaux:
```
#!/usr/bin/env python

def split_raw(val, sep='\n'):
  r"""Split a string on newlines (by default).

  >>> split_raw('alpha\nbeta\ngamma')
  ['alpha', 'beta', 'gamma']
  """
  return val.split(sep)


def split_esc(val, sep='\n'):
  """Split a string on newlines (by default).

  >>> split_esc('alpha\\nbeta\\ngamma')
  ['alpha', 'beta', 'gamma']
  """
  return val.split(sep)

import doctest
doctest.testmod()
```
L'effet de l'utilisation de chaînes brutes et de l'effet de la double-échappement (escape le slash) les deux feuilles dans la chaîne de deux caractères, le slash et le n de. Ce code est transmis à l'interpréteur Python, qui prend "slash alors n" signifie "caractère de saut de ligne" à l'intérieur d'une chaîne de caractères littérale.

Utilisez celle que vous préférez.

InformationsquelleAutor arantius
1

Vous devez définir la NORMALIZE_WHITESPACE. ~~Ou, alternativement, la capture de la sortie et de la comparer à la valeur attendue:~~

def dedupe_whitespace(s,spacechars='\t '): """Merge repeated whitespace characters. Example: >>> output = dedupe_whitespace(r"Black\t\tGround") #doctest: +REPORT_NDIFF >>> output == 'Black\tGround' True """

De la doctest section documentation Comment sont Docstring Exemples Reconnu?:

Tous les caractères de tabulation sont élargies à des espaces, à l'aide de 8 colonnes de l'onglet
s'arrête. Les onglets dans la sortie générée par le code testé ne sont pas modifiés.
Parce que tout dur onglets dans l'exemple de sortie sont élargi, ce qui signifie
que si le code de sortie comprend des onglets, la seule façon de le doctest
peut passer si l'
NORMALIZE_WHITESPACE
l'option ou de la directive est en vigueur. Sinon, le test peut être
réécrit pour capturer la sortie et de la comparer à une valeur attendue comme
une partie de l'épreuve. Cette manipulation des onglets dans la source était arrivé à
par essai et erreur, et s'est avéré être le moins sujettes à erreur
façon de les manipuler. Il est possible d'utiliser un algorithme différent pour
la manipulation des onglets par la rédaction d'un personnalisé DocTestParser classe.

Edit: Mon erreur, j'ai compris la documentation dans l'autre sens. Les onglets sont en train d'être étendu à 8 espaces à la fois de la chaîne argument passé à dedupe_whitespace et le littéral de chaîne en cours par rapport à la ligne suivante, de sorte output contient:
```
"Black Ground"
```
et est comparé:
```
"Black        Ground"
```
Je ne peux pas trouver un moyen de surmonter cette limitation sans écrire votre propre DocTestParser ou de test pour dédupliquées des espaces à la place des onglets.
- Ahh, ne pense pas à faire de capture et de comparer manuellement. C'est exactement ce dont j'avais besoin. Je ne voulais pas utiliser de NORMALIZE_WHITESPACE (parce que je suis mise à l'essai d'un script qui modifie les espaces).
- Juste essayé votre doctest chaîne et il a échoué. Essayé à peu près toutes les combinaisons de double-échappement, unique en les citant, et des matières premières chaînes de caractères en entrée et en sortie. ...in __main__.dedupe_whitespace Failed example: output == 'Black Ground' Expected: True Got: False
- Merci pour creuser dans les docs. J'avais fait la même chose et fait la même erreur. Aussi loin que je peux dire, à l'aide de r""" empêche onglet expansion, à la fois dans l'expression de test et le résultat du test de chaîne littérale.
InformationsquelleAutor Chewie
1

TL;DR: Échapper à la barre oblique inverse, c'est à dire, utiliser \\n ou \\t au lieu de \n ou \t dans votre autrement modifiées chaînes;

Vous ne voulez probablement pas à faire votre docstrings cru que vous ne serez pas en mesure d'utiliser l'un de chaîne Python échappe, y compris ceux que vous pourriez vouloir.

Pour une méthode qui prend en charge l'utilisation normale échappe, juste d'échapper à la barre oblique inverse dans la barre oblique caractères d'échappement ainsi, après Python interprète, il laisse un backslash suivi par le personnage qui doctest peut analyser.

InformationsquelleAutor Yatharth Agarwal
1

Je l'ai eu à travailler pour s'évader le caractère de tabulation dans la chaîne attendue:
```
>>> function_that_returns_tabbed_text()
'\\t\\t\\tsometext\\t\\t'
```
au lieu de
```
>>> function_that_returns_tabbed_text()
\t\t\tsometext\t\t
```
InformationsquelleAutor Jacob Nowitzky

Vous devez vous connecter pour publier un commentaire.