मैं पाइथन डॉक्टेस्ट परिणाम स्ट्रिंग में विशेष वर्ण (टैब, न्यूलाइन) कैसे शामिल कर सकता हूं?

Question

निम्नलिखित अजगर स्क्रिप्ट को देखते हुए:

# 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 

के रूप में अजगर दुभाषिया के भीतर इरादा समारोह काम करता है:

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

हालांकि, doctest उदाहरण में विफल रहता है क्योंकि टैब वर्ण परिणाम की तुलना से पहले रिक्त स्थान में बदल रही हैं स्ट्रिंग:

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

देता है

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

मैं एक डॉक्टरेट हेड्रोक स्ट्रिंग में टैब वर्णों को कैसे एन्कोड कर सकता हूं ताकि परीक्षण परिणाम तुलना उचित तरीके से की जा सके?

Answer 1

मैं इस 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() 

Answer 2

आपको NORMALIZE_WHITESPACE सेट करना होगा। या, वैकल्पिक रूप से, आउटपुट को कैप्चर और उम्मीद मूल्य की तुलना:

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 
    """ 

doctest प्रलेखन अनुभाग How are Docstring Examples Recognized? से:

सभी कठिन टैब वर्ण रिक्त स्थान के लिए विस्तार कर रहे हैं, 8-कॉलम टैब स्टॉप का उपयोग करना बंद कर देता है। परीक्षण कोड द्वारा उत्पन्न आउटपुट में टैब संशोधित नहीं हैं। क्योंकि नमूना उत्पादन में किसी भी मुश्किल टैब का विस्तार कर रहे हैं, इस मतलब यह है कि कोड उत्पादन मुश्किल टैब, एक ही रास्ता है, तो NORMALIZE_WHITESPACE विकल्प या निर्देश प्रभाव में है doctest से पारित सकता है शामिल है। वैकल्पिक रूप से, परीक्षण आउटपुट को कैप्चर करने के लिए पुनः लिखा जा सकता है और इसे परीक्षण के भाग के रूप में अपेक्षित मान से तुलना कर सकता है। स्रोत में टैब का यह संभालना परीक्षण और त्रुटि के माध्यम से पर पहुंचा था, और कम से कम त्रुटि प्रवण उन्हें संभालने का तरीका साबित हुआ है। कस्टम DocTestParser कक्षा लिखकर हैंडलिंग टैब के लिए एक अलग एल्गोरिदम का उपयोग करना संभव है।

संपादित करें: मेरे गलती, मैं डॉक्स दूसरी तरह के आसपास समझा। टैब्स दोनों स्ट्रिंग तर्क dedupe_whitespace और स्ट्रिंग के लिए पारित 8 रिक्त स्थान के लिए विस्तारित किया जा रहा है शाब्दिक अगली पंक्ति की तुलना में किया जा रहा है, इसलिए output शामिल हैं:

"Black Ground" 

और की तुलना में किया जा रहा है:

"Black  Ground" 

मुझे अपने स्वयं के DocTestParser लिखने या टैब के बजाय deduplicated रिक्त स्थान के परीक्षण के बिना इस सीमा को दूर करने का कोई तरीका नहीं मिल रहा है।

Answer 3

यह कच्चे हियरडॉक स्ट्रिंग संकेतन (r""") है कि चाल किया:

# 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() 

Answer 4

टी एल; डीआर: बैकस्लैश से बचें, यानी \\n या \\t\n या \t के बजाय अन्यथा अनमोडिफाइड तारों में उपयोग करें;

शायद आप अपने डॉकस्ट्रिंग को कच्चे नहीं बनाना चाहते हैं, तो आप किसी भी पायथन स्ट्रिंग एस्केप का उपयोग करने में सक्षम नहीं होंगे, जिन्हें आप चाहें।

सामान्य एस्केप का उपयोग करने में सहायता करने वाली विधि के लिए, बैकस्लैश-वर्ण से बचने के लिए बैकस्लैश से बचें ताकि पाइथन इसका अर्थ समझने के बाद, यह एक शाब्दिक बैकस्लैश छोड़ देता है जिसके बाद doctest पार्स कर सकता है।

Answer 5

यह मूल रूप से याथहर्रोक का जवाब है, लेकिन थोड़ा और स्पष्ट है। आप कच्चे तार या डबल एस्केपिंग का उपयोग कर सकते हैं। पर क्यों?

आपको वैध पायथन कोड रखने के लिए स्ट्रिंग अक्षर की आवश्यकता है, जब व्याख्या की गई है, वह कोड है जिसे आप चलाने/परीक्षण करना चाहते हैं। ये दोनों काम:

#!/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() 

कच्चे तार का उपयोग कर के प्रभाव और के प्रभाव से बचने के डबल (स्लेश भागने) स्ट्रिंग दो अक्षर, स्लैश और n में दोनों पत्ते। यह कोड पाइथन दुभाषिया को पास किया गया है, जो स्ट्रिंग अक्षर के अंदर "न्यूलाइन कैरेक्टर" का अर्थ है "स्लैश तो एन" लेता है।

जो भी आप चाहें उसका उपयोग करें।