python怎么输入汉字输出它的编码_python在Windows命令行窗口(cmd)实现utf8编码中文输入输出...

执行以下函数后即可实现中文输入输出

#-*- coding: utf-8 -*-

def utf8writer_register():

import sys

if sys.platform == "win32":

import codecs

from ctypes import WINFUNCTYPE, windll, POINTER, byref, c_int

from ctypes.wintypes import BOOL, HANDLE, DWORD, LPWSTR, LPCWSTR, LPVOID

original_stderr = sys.stderr

# If any exception occurs in this code, we'll probably try to print it on stderr,

# which makes for frustrating debugging if stderr is directed to our wrapper.

# So be paranoid about catching errors and reporting them to original_stderr,

# so that we can at least see them.

def _complain(message):

print >> original_stderr, message if isinstance(message, str) else repr(message)

# Work around .

codecs.register(lambda name: codecs.lookup('utf-8') if name == 'cp65001' else None)

# Make Unicode console output work independently of the current code page.

# This also fixes .

# Credit to Michael Kaplan

# and TZOmegaTZIOY

# .

try:

#

# HANDLE WINAPI GetStdHandle(DWORD nStdHandle);

# returns INVALID_HANDLE_VALUE, NULL, or a valid handle

#

#

# DWORD WINAPI GetFileType(DWORD hFile);

#

#

# BOOL WINAPI GetConsoleMode(HANDLE hConsole, LPDWORD lpMode);

GetStdHandle = WINFUNCTYPE(HANDLE, DWORD)(("GetStdHandle", windll.kernel32))

STD_INPUT_HANDLE = DWORD(-10)

STD_OUTPUT_HANDLE = DWORD(-11)

STD_ERROR_HANDLE = DWORD(-12)

GetFileType = WINFUNCTYPE(DWORD, DWORD)(("GetFileType", windll.kernel32))

FILE_TYPE_CHAR = 0x0002

FILE_TYPE_REMOTE = 0x8000

GetConsoleMode = WINFUNCTYPE(BOOL, HANDLE, POINTER(DWORD))(("GetConsoleMode", windll.kernel32))

INVALID_HANDLE_VALUE = DWORD(-1).value

def not_a_console(handle):

if handle == INVALID_HANDLE_VALUE or handle is None:

return True

return ((GetFileType(handle) & ~FILE_TYPE_REMOTE) != FILE_TYPE_CHAR

or GetConsoleMode(handle, byref(DWORD())) == 0)

# old_stdin_fileno = None

old_stdout_fileno = None

old_stderr_fileno = None

# if hasattr(sys.stdin, 'fileno'):

# old_stdin_fileno = sys.stdin.fileno()

if hasattr(sys.stdout, 'fileno'):

old_stdout_fileno = sys.stdout.fileno()

if hasattr(sys.stderr, 'fileno'):

old_stderr_fileno = sys.stderr.fileno()

# STDIN_FILENO = 0

STDOUT_FILENO = 1

STDERR_FILENO = 2

# real_stdin = (old_stdin_fileno == STDIN_FILENO)

real_stdout = (old_stdout_fileno == STDOUT_FILENO)

real_stderr = (old_stderr_fileno == STDERR_FILENO)

# if real_stdin:

# hStdin = GetStdHandle(STD_INPUT_HANDLE)

# if not_a_console(hStdin):

# real_stdin = False

if real_stdout:

hStdout = GetStdHandle(STD_OUTPUT_HANDLE)

if not_a_console(hStdout):

real_stdout = False

if real_stderr:

hStderr = GetStdHandle(STD_ERROR_HANDLE)

if not_a_console(hStderr):

real_stderr = False

if real_stdout or real_stderr: # or real_stdin

# BOOL WINAPI WriteConsoleW(HANDLE hOutput, LPWSTR lpBuffer, DWORD nChars,

# LPDWORD lpCharsWritten, LPVOID lpReserved);

WriteConsoleW = WINFUNCTYPE(BOOL, HANDLE, LPWSTR, DWORD, POINTER(DWORD), LPVOID)(

("WriteConsoleW", windll.kernel32))

class UnicodeOutput:

def __init__(self, hConsole, stream, fileno, name):

self._hConsole = hConsole

self._stream = stream

self._fileno = fileno

self.closed = False

self.softspace = False

self.mode = 'w'

self.encoding = 'utf-8'

self.name = name

self.flush()

def isatty(self):

return False

def close(self):

# don't really close the handle, that would only cause problems

self.closed = True

def fileno(self):

return self._fileno

def flush(self):

if self._hConsole is None:

try:

self._stream.flush()

except Exception as e:

_complain("%s.flush: %r from %r" % (self.name, e, self._stream))

raise

def write(self, text):

try:

if self._hConsole is None:

if isinstance(text, unicode):

text = text.encode('utf-8')

self._stream.write(text)

else:

if not isinstance(text, unicode):

text = str(text).decode('utf-8')

remaining = len(text)

while remaining:

n = DWORD(0)

# There is a shorter-than-documented limitation on the

# length of the string passed to WriteConsoleW (see

# .

retval = WriteConsoleW(self._hConsole, text, min(remaining, 10000), byref(n), None)

if retval == 0 or n.value == 0:

raise IOError("WriteConsoleW returned %r, n.value = %r" % (retval, n.value))

remaining -= n.value

if not remaining:

break

text = text[n.value:]

except Exception as e:

_complain("%s.write: %r" % (self.name, e))

raise

def writelines(self, lines):

try:

for line in lines:

self.write(line)

except Exception as e:

_complain("%s.writelines: %r" % (self.name, e))

raise

def read(self, n=1):

return unicode(self._stream.read(n), self._stream.encoding)

def readinto(self, b):

return unicode(self._stream.readinto(b), self._stream.encoding)

def readline(self, limit=-1):

return unicode(self._stream.readline(limit), self._stream.encoding)

def readlines(self, limit=-1):

result = [unicode(s, self._stream.encoding) for s in self._stream.readlines(limit)]

return result

#if real_stdin:

#sys.stdin = UnicodeOutput(hStdin, None, STDIN_FILENO, '')

#else:

# It is more difficult to read from hStdin than write to hStdout,

# cause bottom line fully work for me,

# I haven't implemented it with win32api(ReadConsole).

sys.stdin = UnicodeOutput(None, sys.stdin, sys.stdin.fileno(), '')

if real_stdout:

sys.stdout = UnicodeOutput(hStdout, None, STDOUT_FILENO, '')

else:

sys.stdout = UnicodeOutput(None, sys.stdout, old_stdout_fileno, '')

if real_stderr:

sys.stderr = UnicodeOutput(hStderr, None, STDERR_FILENO, '')

else:

sys.stderr = UnicodeOutput(None, sys.stderr, old_stderr_fileno, '')

except Exception as e:

_complain("exception %r while fixing up sys.stdout and sys.stderr" % (e,))

# While we're at it, let's unmangle the command-line arguments:

# This works around .

GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))

CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(

("CommandLineToArgvW", windll.shell32))

argc = c_int(0)

argv_unicode = CommandLineToArgvW(GetCommandLineW(), byref(argc))

argv = [argv_unicode[i].encode('utf-8') for i in xrange(0, argc.value)]

if not hasattr(sys, 'frozen'):

# If this is an executable produced by py2exe or bbfreeze, then it will

# have been invoked directly. Otherwise, unicode_argv[0] is the Python

# interpreter, so skip that.

argv = argv[1:]

# Also skip option arguments to the Python interpreter.

while len(argv) > 0:

arg = argv[0]

if not arg.startswith(u"-") or arg == u"-":

break

argv = argv[1:]

if arg == u'-m':

# sys.argv[0] should really be the absolute path of the module source,

# but never mind

break

if arg == u'-c':

argv[0] = u'-c'

break

# if you like:

sys.argv = argv