පයිතන්හි stderr වෙත මුද්‍රණය කරන්නේ කෙසේද?

Stderr වෙත ලිවීමට ක්‍රම කිහිපයක් තිබේ:

# Note: this first one does not work in Python 3
print >> sys.stderr, "spam"

sys.stderr.write("spam\n")

os.write(2, b"spam\n")

from __future__ import print_function
print("spam", file=sys.stderr)

බව පටහැනි බව පෙනේ Python ක Zen # 13 ^† ඒ දේ මෙහි වෙනස, සහ එක් ආකාරයකින් හෝ තවත් කිසිදු වාසි හෝ අවාසි පවතින බවත්; භාවිතා කළ යුතු මාර්ගය කුමක්ද?

^† _{හා වඩාත් සුදුසු එකම එක - - එය කිරීමට පැහැදිලි මඟ එක් තිබිය යුතුයි.}

කෙටි + නම්‍යශීලී + අතේ ගෙන යා හැකි + කියවිය හැකි එකම එක මෙය බව මට පෙනී ගියේය:

from __future__ import print_function
import sys

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)

ශ්‍රිතය eprintසම්මත printශ්‍රිතයට සමාන ආකාරයකින් භාවිතා කළ හැකිය :

>>> print("Test")
Test
>>> eprint("Test")
Test
>>> eprint("foo", "bar", "baz", sep="---")
foo---bar---baz

import sys
sys.stderr.write()

මගේ තේරීම, වඩා කියවිය හැකි සහ ඔබ කිරීමට අදහස් කරන දේ හරියටම කියමින් අනුවාද හරහා ගෙන යා හැකි ද?

සංස්කරණය කරන්න: 'පයිතොනික්' වීම කියවීමේ හැකියාව සහ ක්‍රියාකාරිත්වය පිළිබඳ තුන්වන අදහසකි ... මේ කාරණා දෙක මනසේ තබාගෙන, පයිතන් සමඟ ඔබේ කේතයෙන් 80% ක් පයිතොනික් වනු ඇත. ලැයිස්තු අවබෝධය බොහෝ විට භාවිතා නොකරන 'විශාල දෙය' (කියවීමේ හැකියාව).

print >> sys.stderrපයිතන් 3 හි ගොස් ඇත. http://docs.python.org/3.0/whatsnew/3.0.html පවසයි:

Old: print >> sys.stderr, "fatal error"
New: print("fatal error", file=sys.stderr)

අපගෙන් බොහෝ දෙනෙකුට, විධානයේ අවසානය දක්වා ගමනාන්තය බැහැර කිරීම තරමක් අස්වාභාවික බවක් දැනේ. විකල්පය

sys.stderr.write("fatal error\n")

වඩා වස්තූන් නැඹුරු බව පෙනේ, සහ අලංකාරය සාමාන්‍ය සිට නිශ්චිත දක්වා යයි. නමුත් writeඑය 1: 1 ආදේශකයක් නොවන බව සලකන්න print.

කිසිවෙකු loggingතවම සඳහන් කර නැත, නමුත් දෝෂ පණිවිඩ සන්නිවේදනය කිරීම සඳහා විශේෂයෙන් ලොග් වීම නිර්මාණය කරන ලදි. මූලික වින්‍යාසය මඟින් stderr වෙත ප්‍රවාහ හසුරුවන ලිවීමක් සැකසෙනු ඇත.

මෙම පිටපත:

# foo.py
import logging

logging.basicConfig(format='%(message)s')
log = logging.getLogger(__name__)
log.warning('I print to stderr by default')
print('hello world')

විධාන රේඛාවේ ධාවනය වන විට පහත ප්‍රති result ලය ඇත:

$ python3 foo.py > bar.txt
I print to stderr by default

සහ bar.txt හි stdout හි මුද්‍රණය කර ඇති 'හෙලෝ වර්ල්ඩ්' අඩංගු වේ.

සඳහා python, 2 මගේ තේරීම වේ: print >> sys.stderr, 'spam' ඔබ හුදෙක් ලැයිස්තු / dicts ආදිය ආගමට හරවා තොරව එය string කිරීමට මුද්රණය කළ හැක නිසා. print >> sys.stderr, {'spam': 'spam'} වෙනුවට: sys.stderr.write(str({'spam': 'spam'}))

මම පහත සඳහන් දේ කළේ පයිතන් 3 භාවිතා කරමිනි:

from sys import stderr

def print_err(*args, **kwargs):
    print(*args, file=stderr, **kwargs)

එබැවින් දැන් මට යතුරුපද තර්ක එකතු කිරීමට හැකි වී ඇත, උදාහරණයක් ලෙස, කරත්ත නැවත පැමිණීම වළක්වා ගැනීමට:

print_err("Error: end of the file reached. The word ", end='')
print_err(word, "was not found")

ඔබේ පළමු ප්‍රවේශය:

print >> sys.stderr, 'spam' 

යනු “එකකි. එය කළ හැකි පැහැදිලි ක්‍රමය” අනෙක් අය රීතිය # 1 තෘප්තිමත් නොකරයි (“කැතට වඩා ලස්සනයි.”)

මෙය සම්මත මුද්‍රණ ශ්‍රිතය අනුකරණය කරන නමුත් stderr මත ප්‍රතිදානය කරයි

def print_err(*args):
    sys.stderr.write(' '.join(map(str,args)) + '\n')

පයිතන් 3 හි කෙනෙකුට මුද්‍රණය () භාවිතා කළ හැකිය :

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

කොටුවෙන් පිටත:

import sys
print("Hello, world!", file=sys.stderr)

හෝ:

from sys import stderr
print("Hello, world!", file=stderr)

මෙය සරල වන අතර ඒ හැර වෙනත් කිසිවක් ඇතුළත් කිරීම අවශ්‍ය නොවේ sys.stderr.

සංස්කරණය කරන්න sys.stderr වෙනස් කිරීම හා හැසිරීම යාවත්කාලීන නොවීම සමඟ ඇති විය හැකි ව්‍යාකූලත්වය මෙම පිළිතුර අනෙක් අය පෙන්වා දී ඇති පරිදි සරල ශ්‍රිතයක් භාවිතා කිරීම තරම් හොඳ නොවන බව මම සිතමි.

අර්ධ වශයෙන් පමණක් භාවිතා කිරීමෙන් ඔබට කේත පේළි 1 ක් ඉතිරි වේ. විභව ව්යාකූලත්වය කේත පේළි 1 ක් ඉතිරි කිරීම වටී නැත.

මුල්

එය වඩාත් පහසු කිරීම සඳහා, මෙහි 'අර්ධ' භාවිතා කරන අනුවාදයක් ඇත, එය කාර්යයන් එතීමට විශාල උපකාරයකි.

from __future__ import print_function
import sys
from functools import partial

error = partial(print, file=sys.stderr)

ඔබ එය එසේ භාවිතා කරයි

error('An error occured!')

පහත සඳහන් දෑ සිදු කිරීමෙන් එය stderr වෙත මුද්‍රණය වනවාද යන්න පරීක්ෂා කළ හැකිය ( http://coreygoldberg.blogspot.com.au/2009/05/python-redirect-or-turn-off-stdout-and .html ):

# over-ride stderr to prove that this function works.
class NullDevice():
    def write(self, s):
        pass
sys.stderr = NullDevice()

# we must import print error AFTER we've removed the null device because
# it has been assigned and will not be re-evaluated.
# assume error function is in print_error.py
from print_error import error

# no message should be printed
error("You won't see this error!")

මේ එහි අවාසිය අර්ධ වේ පැවරුම් නිර්මාණය කරන අවස්ථාවේ දී ඔතා කටයුතු කිරීමට sys.stderr වටිනාකම. එයින් අදහස් වන්නේ, ඔබ පසුව stderr නැවත හරවා යැවුවහොත් එය මෙම ශ්‍රිතයට බලපාන්නේ නැත. ඔබ stderr යළි හරවා යැවීමට අදහස් කරන්නේ නම්, මෙම පිටුවේ aaguirre විසින් සඳහන් කර ඇති ** kwargs ක්‍රමය භාවිතා කරන්න.

Stdout සඳහා ද මෙය අදාළ වේ:

print 'spam'
sys.stdout.write('spam\n')

අනෙක් පිළිතුරු වල සඳහන් පරිදි, මුද්‍රණය බොහෝ විට වඩාත් පහසු (උදා: නිදොස් කිරීමේ තොරතුරු මුද්‍රණය කිරීම සඳහා) ලස්සන අතුරු මුහුණතක් ඉදිරිපත් කරයි, ලිවීම වේගවත් වන අතර ප්‍රතිදානය නිශ්චිත ආකාරයකින් සංයුති කිරීමට සිදු වන විට වඩාත් පහසු වේ. නඩත්තු කිරීමේ හැකියාව ද මම සලකා බලමි:

1. ඔබට පසුව stdout / stderr සහ සාමාන්‍ය ගොනුවක් අතර මාරු වීමට තීරණය කළ හැකිය.

2. පයිතන් 3 හි මුද්‍රණය () වාක්‍ය ඛණ්ඩය වෙනස් වී ඇත, එබැවින් ඔබට අනුවාද දෙකටම සහය දැක්වීමට අවශ්‍ය නම් () ලිවීම වඩා හොඳ විය හැකිය.

මම වැඩ කරන්නේ පයිතන් 3.4.3. මම මෙහි යතුරු ලියනය කරන ආකාරය පෙන්වන කුඩා ටයිප් කිරීමක් කපා දමමි:

[18:19 jsilverman@JSILVERMAN-LT7 pexpect]$ python3
>>> import sys
>>> print("testing", file=sys.stderr)
testing
>>>
[18:19 jsilverman@JSILVERMAN-LT7 pexpect]$ 

එය වැඩ කලාද? Stderr ගොනුවකට හරවා යැවීමට උත්සාහ කර සිදුවන්නේ කුමක්දැයි බලන්න:

[18:22 jsilverman@JSILVERMAN-LT7 pexpect]$ python3 2> /tmp/test.txt
>>> import sys
>>> print("testing", file=sys.stderr)
>>> [18:22 jsilverman@JSILVERMAN-LT7 pexpect]$
[18:22 jsilverman@JSILVERMAN-LT7 pexpect]$ cat /tmp/test.txt
Python 3.4.3 (default, May  5 2015, 17:58:45)
[GCC 4.9.2] on cygwin
Type "help", "copyright", "credits" or "license" for more information.
testing

[18:22 jsilverman@JSILVERMAN-LT7 pexpect]$

හොඳයි, පයිතන් ඔබට ලබා දෙන කුඩා හැඳින්වීම පසෙකට දමා ඇත (එය වෙනත් තැනකට යන්නේ කෙසේද?), එය ක්‍රියාත්මක වේ.

ඔබ සරල පරීක්ෂණයක් කරන්නේ නම්:

import time
import sys

def run1(runs):
    x = 0
    cur = time.time()
    while x < runs:
        x += 1
        print >> sys.stderr, 'X'
    elapsed = (time.time()-cur)
    return elapsed

def run2(runs):
    x = 0
    cur = time.time()
    while x < runs:
        x += 1
        sys.stderr.write('X\n')
        sys.stderr.flush()
    elapsed = (time.time()-cur)
    return elapsed

def compare(runs):
    sum1, sum2 = 0, 0
    x = 0
    while x < runs:
        x += 1
        sum1 += run1(runs)
        sum2 += run2(runs)
    return sum1, sum2

if __name__ == '__main__':
    s1, s2 = compare(1000)
    print "Using (print >> sys.stderr, 'X'): %s" %(s1)
    print "Using (sys.stderr.write('X'),sys.stderr.flush()):%s" %(s2)
    print "Ratio: %f" %(float(s1) / float(s2))

Sys.stderr.write () නිරතුරුවම 1.81 ගුණයකින් වේගවත් බව ඔබට පෙනී යනු ඇත!

මාරාන්තික දෝෂයක් හේතුවෙන් ඔබට වැඩසටහනකින් ඉවත් වීමට අවශ්‍ය නම්, මෙය භාවිතා කරන්න:

sys.exit("Your program caused a fatal error. ... description ...")

සහ import sysශීර්ෂය තුළ.

ප්‍රශ්නයට පිළිතුර: පයිතන්හි stderr මුද්‍රණය කිරීමට වෙනස් ක්‍රම ඇති නමුත් එය 1 මත රඳා පවතී.) අපි භාවිතා කරන්නේ කුමන පයිතන් අනුවාදයද?) අපට අවශ්‍ය නිශ්චිත ප්‍රතිදානය.

මුද්‍රණ සහ ස්ටෙඩර්ගේ ලිවීමේ කාර්යය අතර ඇති වෙනස: stderr : stderr (සම්මත දෝෂය) යනු සෑම යුනික්ස් / ලිනක්ස් පද්ධතියකටම ගොඩනගා ඇති නලයකි, ඔබේ වැඩසටහන බිඳ වැටී නිදොස් කිරීමේ තොරතුරු මුද්‍රණය කරන විට (පයිතන්හි ලුහුබැඳීමක් වැනි), එය ස්ටෙඩර් වෙත යයි පයිප්ප.

මුද්‍රණය කරන්න : print යනු ආදාන ආකෘතිකරණය කරන එතීමකි (ආදානය යනු තර්කය සහ නව රේඛාව අවසානයේ ඇති අවකාශයයි) එවිට එය දී ඇති වස්තුවක ලිවීමේ කාර්යය ලෙස හැඳින්වේ, ලබා දී ඇති වස්තුව පෙරනිමියෙන් sys.stdout වේ, නමුත් අපට හැකිය ගොනුවක් සම්මත කරන්න, එනම් අපට ආදානය ගොනුවක මුද්‍රණය කළ හැකිය.

පයිතන් 2: අපි පයිතන් 2 භාවිතා කරන්නේ නම්

>>> import sys
>>> print "hi"
hi
>>> print("hi")
hi
>>> print >> sys.stderr.write("hi")
hi

පයිතන් 2 පසුපස කොමාව පරාමිතියක් බවට පත්ව ඇත, එබැවින් මුද්‍රණයෙන් පසු නව රේඛාව මඟ හැරීම සඳහා අපි පසුපස කොමාව භාවිතා කරන්නේ නම්, මෙය පයිතන් 3 හි මුද්‍රණය මෙන් පෙනේ ('මුද්‍රණය කිරීමට පෙළ', අවසානය = '') එය පයිතන් 2 යටතේ ඇති සින්ටැක්ස් දෝෂයකි. .

http://python3porting.com/noconv.html

අපි python3 හි ඉහත sceario එක පරීක්ෂා කළහොත්:

>>> import sys
>>> print("hi")
hi

පයිතන් 2.6 යටතේ මුද්‍රණය ශ්‍රිතයක් බවට පත් කිරීම සඳහා අනාගත ආනයනයක් ඇත. එබැවින් සින්ටැක්ස් දෝෂ සහ වෙනත් වෙනස්කම් වලක්වා ගැනීම සඳහා අපි අනාගත ආනයන print_function වෙතින් මුද්‍රණ () භාවිතා කරන ඕනෑම ගොනුවක් ආරම්භ කළ යුතුය . මෙම අනාගත ආනයන පමණක් Python 2.6 යටතේ ක්රියා කරන අතර පසුව, ඒ නිසා Python 2.5 හා ඉන් පෙර ඔබට විකල්ප දෙකක් ඇත. ඔබට වඩාත් සංකීර්ණ මුද්‍රණය සරල දෙයකට පරිවර්තනය කළ හැකිය, නැතහොත් ඔබට පයිතන් 2 සහ පයිතන් 3 යටතේ ක්‍රියාත්මක වන වෙනම මුද්‍රණ ශ්‍රිතයක් භාවිතා කළ හැකිය.

>>> from __future__ import print_function
>>> 
>>> def printex(*args, **kwargs):
...     print(*args, file=sys.stderr, **kwargs)
... 
>>> printex("hii")
hii
>>>

නඩුව: සැලකිල්ලට ගත යුතු කරුණ නම් sys.stderr.write () හෝ sys.stdout.write () (stdout (සම්මත ප්‍රතිදානය) යනු සෑම යුනික්ස් / ලිනක්ස් පද්ධතියක් තුළම ගොඩනගා ඇති නලයකි) මුද්‍රණය සඳහා ආදේශකයක් නොවන නමුත් ඔව් අපට එය යම් අවස්ථාවක විකල්පයක් ලෙස භාවිතා කළ හැකිය. මුද්‍රණය යනු ආදාන අවකාශය හා නව රේඛාව සමඟ ඔතා අවසානයේ ලිවීමේ කාර්යය භාවිතා කරයි. Sys.stderr.write () වේගවත් වීමට හේතුව මෙයයි.

සටහන: අපට ලොග් වීම භාවිතා කර නිදොස්කරණය කළ හැකිය

#test.py
import logging
logging.info('This is the existing protocol.')
FORMAT = "%(asctime)-15s %(clientip)s %(user)-8s %(message)s"
logging.basicConfig(format=FORMAT)
d = {'clientip': '192.168.0.1', 'user': 'fbloggs'}
logging.warning("Protocol problem: %s", "connection reset", extra=d)

https://docs.python.org/2/library/logging.html#logger-objects