Python运行报错UnicodeDecodeError的解决方法

时间：2021-10-30 07:32:06

Python2.7在Windows上有一个bug，运行报错：

?
1
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc4 in position 33: ordinal not in range(128)

解决方案如下：

编辑Python27\Lib\mimetypes.py文件，全选，替换为以下patch后的正确脚本，或者直接依据此patch修改：

  1. """Guess the MIME type of a file. 
  2.   
  3. This module defines two useful functions: 
  4.   
  5. guess_type(url, strict=1) -- guess the MIME type and encoding of a URL. 
  6.   
  7. guess_extension(type, strict=1) -- guess the extension for a given MIME type. 
  8.   
  9. It also contains the following, for tuning the behavior: 
  10.   
  11. Data: 
  12.   
  13. knownfiles -- list of files to parse 
  14. inited -- flag set when init() has been called 
  15. suffix_map -- dictionary mapping suffixes to suffixes 
  16. encodings_map -- dictionary mapping suffixes to encodings 
  17. types_map -- dictionary mapping suffixes to types 
  18.   
  19. Functions: 
  20.   
  21. init([files]) -- parse a list of files, default knownfiles (on Windows, the 
  22.  default values are taken from the registry) 
  23. read_mime_types(file) -- parse one file, return a dictionary or None 
  24. """ 
  25. from itertools import count 
  26.   
  27. import os 
  28. import sys 
  29. import posixpath 
  30. import urllib 
  31. try: 
  32.  import _winreg 
  33. except ImportError: 
  34.  _winreg = None 
  35.   
  36. __all__ = [ 
  37.  "guess_type","guess_extension","guess_all_extensions", 
  38.  "add_type","read_mime_types","init" 
  39. ] 
  40.   
  41. knownfiles = [ 
  42.  "/etc/mime.types", 
  43.  "/etc/httpd/mime.types",     # Mac OS X 
  44.  "/etc/httpd/conf/mime.types",    # Apache 
  45.  "/etc/apache/mime.types",     # Apache 1 
  46.  "/etc/apache2/mime.types",     # Apache 2 
  47.  "/usr/local/etc/httpd/conf/mime.types", 
  48.  "/usr/local/lib/netscape/mime.types", 
  49.  "/usr/local/etc/httpd/conf/mime.types",  # Apache 1.2 
  50.  "/usr/local/etc/mime.types",    # Apache 1.3 
  51.  ] 
  52.   
  53. inited = False 
  54. _db = None 
  55.   
  56.   
  57. class MimeTypes: 
  58.  """MIME-types datastore. 
  59.   
  60.  This datastore can handle information from mime.types-style files 
  61.  and supports basic determination of MIME type from a filename or 
  62.  URL, and can guess a reasonable extension given a MIME type. 
  63.  """ 
  64.   
  65.  def __init__(self, filenames=(), strict=True): 
  66.   if not inited: 
  67.    init() 
  68.   self.encodings_map = encodings_map.copy() 
  69.   self.suffix_map = suffix_map.copy() 
  70.   self.types_map = ({}, {}) # dict for (non-strict, strict) 
  71.   self.types_map_inv = ({}, {}) 
  72.   for (ext, type) in types_map.items(): 
  73.    self.add_type(type, ext, True) 
  74.   for (ext, type) in common_types.items(): 
  75.    self.add_type(type, ext, False) 
  76.   for name in filenames: 
  77.    self.read(name, strict) 
  78.   
  79.  def add_type(self, type, ext, strict=True): 
  80.   """Add a mapping between a type and an extension. 
  81.   
  82.   When the extension is already known, the new 
  83.   type will replace the old one. When the type 
  84.   is already known the extension will be added 
  85.   to the list of known extensions. 
  86.   
  87.   If strict is true, information will be added to 
  88.   list of standard types, else to the list of non-standard 
  89.   types. 
  90.   """ 
  91.   self.types_map[strict][ext] = type 
  92.   exts = self.types_map_inv[strict].setdefault(type, []) 
  93.   if ext not in exts: 
  94.    exts.append(ext) 
  95.   
  96.  def guess_type(self, url, strict=True): 
  97.   """Guess the type of a file based on its URL. 
  98.   
  99.   Return value is a tuple (type, encoding) where type is None if 
  100.   the type can't be guessed (no or unknown suffix) or a string 
  101.   of the form type/subtype, usable for a MIME Content-type 
  102.   header; and encoding is None for no encoding or the name of 
  103.   the program used to encode (e.g. compress or gzip). The 
  104.   mappings are table driven. Encoding suffixes are case 
  105.   sensitive; type suffixes are first tried case sensitive, then 
  106.   case insensitive. 
  107.   
  108.   The suffixes .tgz, .taz and .tz (case sensitive!) are all 
  109.   mapped to '.tar.gz'. (This is table-driven too, using the 
  110.   dictionary suffix_map.) 
  111.   
  112.   Optional `strict' argument when False adds a bunch of commonly found, 
  113.   but non-standard types. 
  114.   """ 
  115.   scheme, url = urllib.splittype(url) 
  116.   if scheme == 'data': 
  117.    # syntax of data URLs: 
  118.    # dataurl := "data:" [ mediatype ] [ ";base64" ] "," data 
  119.    # mediatype := [ type "/" subtype ] *( ";" parameter ) 
  120.    # data  := *urlchar 
  121.    # parameter := attribute "=" value 
  122.    # type/subtype defaults to "text/plain" 
  123.    comma = url.find(',') 
  124.    if comma < 0: 
  125.     # bad data URL 
  126.     return None, None 
  127.    semi = url.find(';', 0, comma) 
  128.    if semi >= 0: 
  129.     type = url[:semi] 
  130.    else: 
  131.     type = url[:comma] 
  132.    if '=' in type or '/' not in type: 
  133.     type = 'text/plain' 
  134.    return type, None   # never compressed, so encoding is None 
  135.   base, ext = posixpath.splitext(url) 
  136.   while ext in self.suffix_map: 
  137.    base, ext = posixpath.splitext(base + self.suffix_map[ext]) 
  138.   if ext in self.encodings_map: 
  139.    encoding = self.encodings_map[ext] 
  140.    base, ext = posixpath.splitext(base) 
  141.   else: 
  142.    encoding = None 
  143.   types_map = self.types_map[True] 
  144.   if ext in types_map: 
  145.    return types_map[ext], encoding 
  146.   elif ext.lower() in types_map: 
  147.    return types_map[ext.lower()], encoding 
  148.   elif strict: 
  149.    return None, encoding 
  150.   types_map = self.types_map[False] 
  151.   if ext in types_map: 
  152.    return types_map[ext], encoding 
  153.   elif ext.lower() in types_map: 
  154.    return types_map[ext.lower()], encoding 
  155.   else: 
  156.    return None, encoding 
  157.   
  158.  def guess_all_extensions(self, type, strict=True): 
  159.   """Guess the extensions for a file based on its MIME type. 
  160.   
  161.   Return value is a list of strings giving the possible filename 
  162.   extensions, including the leading dot ('.'). The extension is not 
  163.   guaranteed to have been associated with any particular data stream, 
  164.   but would be mapped to the MIME type `type' by guess_type(). 
  165.   
  166.   Optional `strict' argument when false adds a bunch of commonly found, 
  167.   but non-standard types. 
  168.   """ 
  169.   type = type.lower() 
  170.   extensions = self.types_map_inv[True].get(type, []) 
  171.   if not strict: 
  172.    for ext in self.types_map_inv[False].get(type, []): 
  173.     if ext not in extensions: 
  174.      extensions.append(ext) 
  175.   return extensions 
  176.   
  177.  def guess_extension(self, type, strict=True): 
  178.   """Guess the extension for a file based on its MIME type. 
  179.   
  180.   Return value is a string giving a filename extension, 
  181.   including the leading dot ('.'). The extension is not 
  182.   guaranteed to have been associated with any particular data 
  183.   stream, but would be mapped to the MIME type `type' by 
  184.   guess_type(). If no extension can be guessed for `type', None 
  185.   is returned. 
  186.   
  187.   Optional `strict' argument when false adds a bunch of commonly found, 
  188.   but non-standard types. 
  189.   """ 
  190.   extensions = self.guess_all_extensions(type, strict) 
  191.   if not extensions: 
  192.    return None 
  193.   return extensions[0] 
  194.   
  195.  def read(self, filename, strict=True): 
  196.   """ 
  197.   Read a single mime.types-format file, specified by pathname. 
  198.   
  199.   If strict is true, information will be added to 
  200.   list of standard types, else to the list of non-standard 
  201.   types. 
  202.   """ 
  203.   with open(filename) as fp: 
  204.    self.readfp(fp, strict) 
  205.   
  206.  def readfp(self, fp, strict=True): 
  207.   """ 
  208.   Read a single mime.types-format file. 
  209.   
  210.   If strict is true, information will be added to 
  211.   list of standard types, else to the list of non-standard 
  212.   types. 
  213.   """ 
  214.   while 1: 
  215.    line = fp.readline() 
  216.    if not line: 
  217.     break 
  218.    words = line.split() 
  219.    for i in range(len(words)): 
  220.     if words[i][0] == '#': 
  221.      del words[i:] 
  222.      break 
  223.    if not words: 
  224.     continue 
  225.    type, suffixes = words[0], words[1:] 
  226.    for suff in suffixes: 
  227.     self.add_type(type, '.' + suff, strict) 
  228.   
  229.  def read_windows_registry(self, strict=True): 
  230.   """ 
  231.   Load the MIME types database from Windows registry. 
  232.   
  233.   If strict is true, information will be added to 
  234.   list of standard types, else to the list of non-standard 
  235.   types. 
  236.   """ 
  237.   
  238.   # Windows only 
  239.   if not _winreg: 
  240.    return 
  241.   
  242.   def enum_types(mimedb): 
  243.    for i in count(): 
  244.     try: 
  245.      yield _winreg.EnumKey(mimedb, i) 
  246.     except EnvironmentError: 
  247.      break 
  248.   
  249.   default_encoding = sys.getdefaultencoding() 
  250.   with _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT, '') as hkcr: 
  251.    for subkeyname in enum_types(hkcr): 
  252.     try: 
  253.      with _winreg.OpenKey(hkcr, subkeyname) as subkey: 
  254.       # Only check file extensions 
  255.       if not subkeyname.startswith("."): 
  256.        continue 
  257.       # raises EnvironmentError if no 'Content Type' value 
  258.       mimetype, datatype = _winreg.QueryValueEx( 
  259.        subkey, 'Content Type') 
  260.       if datatype != _winreg.REG_SZ: 
  261.        continue 
  262.       try: 
  263.        mimetype = mimetype.encode(default_encoding) 
  264.        subkeyname = subkeyname.encode(default_encoding) 
  265.       except UnicodeEncodeError: 
  266.        continue 
  267.       self.add_type(mimetype, subkeyname, strict) 
  268.     except EnvironmentError: 
  269.      continue 
  270.   
  271. def guess_type(url, strict=True): 
  272.  """Guess the type of a file based on its URL. 
  273.   
  274.  Return value is a tuple (type, encoding) where type is None if the 
  275.  type can't be guessed (no or unknown suffix) or a string of the 
  276.  form type/subtype, usable for a MIME Content-type header; and 
  277.  encoding is None for no encoding or the name of the program used 
  278.  to encode (e.g. compress or gzip). The mappings are table 
  279.  driven. Encoding suffixes are case sensitive; type suffixes are 
  280.  first tried case sensitive, then case insensitive. 
  281.   
  282.  The suffixes .tgz, .taz and .tz (case sensitive!) are all mapped 
  283.  to ".tar.gz". (This is table-driven too, using the dictionary 
  284.  suffix_map). 
  285.   
  286.  Optional `strict' argument when false adds a bunch of commonly found, but 
  287.  non-standard types. 
  288.  """ 
  289.  if _db is None: 
  290.   init() 
  291.  return _db.guess_type(url, strict) 
  292.   
  293.   
  294. def guess_all_extensions(type, strict=True): 
  295.  """Guess the extensions for a file based on its MIME type. 
  296.   
  297.  Return value is a list of strings giving the possible filename 
  298.  extensions, including the leading dot ('.'). The extension is not 
  299.  guaranteed to have been associated with any particular data 
  300.  stream, but would be mapped to the MIME type `type' by 
  301.  guess_type(). If no extension can be guessed for `type', None 
  302.  is returned. 
  303.   
  304.  Optional `strict' argument when false adds a bunch of commonly found, 
  305.  but non-standard types. 
  306.  """ 
  307.  if _db is None: 
  308.   init() 
  309.  return _db.guess_all_extensions(type, strict) 
  310.   
  311. def guess_extension(type, strict=True): 
  312.  """Guess the extension for a file based on its MIME type. 
  313.   
  314.  Return value is a string giving a filename extension, including the 
  315.  leading dot ('.'). The extension is not guaranteed to have been 
  316.  associated with any particular data stream, but would be mapped to the 
  317.  MIME type `type' by guess_type(). If no extension can be guessed for 
  318.  `type', None is returned. 
  319.   
  320.  Optional `strict' argument when false adds a bunch of commonly found, 
  321.  but non-standard types. 
  322.  """ 
  323.  if _db is None: 
  324.   init() 
  325.  return _db.guess_extension(type, strict) 
  326.   
  327. def add_type(type, ext, strict=True): 
  328.  """Add a mapping between a type and an extension. 
  329.   
  330.  When the extension is already known, the new 
  331.  type will replace the old one. When the type 
  332.  is already known the extension will be added 
  333.  to the list of known extensions. 
  334.   
  335.  If strict is true, information will be added to 
  336.  list of standard types, else to the list of non-standard 
  337.  types. 
  338.  """ 
  339.  if _db is None: 
  340.   init() 
  341.  return _db.add_type(type, ext, strict) 
  342.   
  343.   
  344. def init(files=None): 
  345.  global suffix_map, types_map, encodings_map, common_types 
  346.  global inited, _db 
  347.  inited = True # so that MimeTypes.__init__() doesn't call us again 
  348.  db = MimeTypes() 
  349.  if files is None: 
  350.   if _winreg: 
  351.    db.read_windows_registry() 
  352.   files = knownfiles 
  353.  for file in files: 
  354.   if os.path.isfile(file): 
  355.    db.read(file) 
  356.  encodings_map = db.encodings_map 
  357.  suffix_map = db.suffix_map 
  358.  types_map = db.types_map[True] 
  359.  common_types = db.types_map[False] 
  360.  # Make the DB a global variable now that it is fully initialized 
  361.  _db = db 
  362.   
  363.   
  364. def read_mime_types(file): 
  365.  try: 
  366.   f = open(file) 
  367.  except IOError: 
  368.   return None 
  369.  db = MimeTypes() 
  370.  db.readfp(f, True) 
  371.  return db.types_map[True] 
  372.   
  373.   
  374. def _default_mime_types(): 
  375.  global suffix_map 
  376.  global encodings_map 
  377.  global types_map 
  378.  global common_types 
  379.   
  380.  suffix_map = { 
  381.   '.tgz': '.tar.gz', 
  382.   '.taz': '.tar.gz', 
  383.   '.tz': '.tar.gz', 
  384.   '.tbz2': '.tar.bz2', 
  385.   '.txz': '.tar.xz', 
  386.   } 
  387.   
  388.  encodings_map = { 
  389.   '.gz': 'gzip', 
  390.   '.Z': 'compress', 
  391.   '.bz2': 'bzip2', 
  392.   '.xz': 'xz', 
  393.   } 
  394.   
  395.  # Before adding new types, make sure they are either registered with IANA, 
  396.  # at http://www.isi.edu/in-notes/iana/assignments/media-types 
  397.  # or extensions, i.e. using the x- prefix 
  398.   
  399.  # If you add to these, please keep them sorted! 
  400.  types_map = { 
  401.   '.a'  : 'application/octet-stream', 
  402.   '.ai'  : 'application/postscript', 
  403.   '.aif' : 'audio/x-aiff', 
  404.   '.aifc' : 'audio/x-aiff', 
  405.   '.aiff' : 'audio/x-aiff', 
  406.   '.au'  : 'audio/basic', 
  407.   '.avi' : 'video/x-msvideo', 
  408.   '.bat' : 'text/plain', 
  409.   '.bcpio' : 'application/x-bcpio', 
  410.   '.bin' : 'application/octet-stream', 
  411.   '.bmp' : 'image/x-ms-bmp', 
  412.   '.c'  : 'text/plain', 
  413.   # Duplicates
  414.   '.cdf' : 'application/x-cdf', 
  415.   '.cdf' : 'application/x-netcdf', 
  416.   '.cpio' : 'application/x-cpio', 
  417.   '.csh' : 'application/x-csh', 
  418.   '.css' : 'text/css', 
  419.   '.dll' : 'application/octet-stream', 
  420.   '.doc' : 'application/msword', 
  421.   '.dot' : 'application/msword', 
  422.   '.dvi' : 'application/x-dvi', 
  423.   '.eml' : 'message/rfc822', 
  424.   '.eps' : 'application/postscript', 
  425.   '.etx' : 'text/x-setext', 
  426.   '.exe' : 'application/octet-stream', 
  427.   '.gif' : 'image/gif', 
  428.   '.gtar' : 'application/x-gtar', 
  429.   '.h'  : 'text/plain', 
  430.   '.hdf' : 'application/x-hdf', 
  431.   '.htm' : 'text/html', 
  432.   '.html' : 'text/html', 
  433.   '.ico' : 'image/vnd.microsoft.icon', 
  434.   '.ief' : 'image/ief', 
  435.   '.jpe' : 'image/jpeg', 
  436.   '.jpeg' : 'image/jpeg', 
  437.   '.jpg' : 'image/jpeg', 
  438.   '.js'  : 'application/javascript', 
  439.   '.ksh' : 'text/plain', 
  440.   '.latex' : 'application/x-latex', 
  441.   '.m1v' : 'video/mpeg', 
  442.   '.man' : 'application/x-troff-man', 
  443.   '.me'  : 'application/x-troff-me', 
  444.   '.mht' : 'message/rfc822', 
  445.   '.mhtml' : 'message/rfc822', 
  446.   '.mif' : 'application/x-mif', 
  447.   '.mov' : 'video/quicktime', 
  448.   '.movie' : 'video/x-sgi-movie', 
  449.   '.mp2' : 'audio/mpeg', 
  450.   '.mp3' : 'audio/mpeg', 
  451.   '.mp4' : 'video/mp4', 
  452.   '.mpa' : 'video/mpeg', 
  453.   '.mpe' : 'video/mpeg', 
  454.   '.mpeg' : 'video/mpeg', 
  455.   '.mpg' : 'video/mpeg', 
  456.   '.ms'  : 'application/x-troff-ms', 
  457.   '.nc'  : 'application/x-netcdf', 
  458.   '.nws' : 'message/rfc822', 
  459.   '.o'  : 'application/octet-stream', 
  460.   '.obj' : 'application/octet-stream', 
  461.   '.oda' : 'application/oda', 
  462.   '.p12' : 'application/x-pkcs12', 
  463.   '.p7c' : 'application/pkcs7-mime', 
  464.   '.pbm' : 'image/x-portable-bitmap', 
  465.   '.pdf' : 'application/pdf', 
  466.   '.pfx' : 'application/x-pkcs12', 
  467.   '.pgm' : 'image/x-portable-graymap', 
  468.   '.pl'  : 'text/plain', 
  469.   '.png' : 'image/png', 
  470.   '.pnm' : 'image/x-portable-anymap', 
  471.   '.pot' : 'application/vnd.ms-powerpoint', 
  472.   '.ppa' : 'application/vnd.ms-powerpoint', 
  473.   '.ppm' : 'image/x-portable-pixmap', 
  474.   '.pps' : 'application/vnd.ms-powerpoint', 
  475.   '.ppt' : 'application/vnd.ms-powerpoint', 
  476.   '.ps'  : 'application/postscript', 
  477.   '.pwz' : 'application/vnd.ms-powerpoint', 
  478.   '.py'  : 'text/x-python', 
  479.   '.pyc' : 'application/x-python-code', 
  480.   '.pyo' : 'application/x-python-code', 
  481.   '.qt'  : 'video/quicktime', 
  482.   '.ra'  : 'audio/x-pn-realaudio', 
  483.   '.ram' : 'application/x-pn-realaudio', 
  484.   '.ras' : 'image/x-cmu-raster', 
  485.   '.rdf' : 'application/xml', 
  486.   '.rgb' : 'image/x-rgb', 
  487.   '.roff' : 'application/x-troff', 
  488.   '.rtx' : 'text/richtext', 
  489.   '.sgm' : 'text/x-sgml', 
  490.   '.sgml' : 'text/x-sgml', 
  491.   '.sh'  : 'application/x-sh', 
  492.   '.shar' : 'application/x-shar', 
  493.   '.snd' : 'audio/basic', 
  494.   '.so'  : 'application/octet-stream', 
  495.   '.src' : 'application/x-wais-source', 
  496.   '.sv4cpio': 'application/x-sv4cpio', 
  497.   '.sv4crc' : 'application/x-sv4crc', 
  498.   '.swf' : 'application/x-shockwave-flash', 
  499.   '.t'  : 'application/x-troff', 
  500.   '.tar' : 'application/x-tar', 
  501.   '.tcl' : 'application/x-tcl', 
  502.   '.tex' : 'application/x-tex', 
  503.   '.texi' : 'application/x-texinfo', 
  504.   '.texinfo': 'application/x-texinfo', 
  505.   '.tif' : 'image/tiff', 
  506.   '.tiff' : 'image/tiff', 
  507.   '.tr'  : 'application/x-troff', 
  508.   '.tsv' : 'text/tab-separated-values', 
  509.   '.txt' : 'text/plain', 
  510.   '.ustar' : 'application/x-ustar', 
  511.   '.vcf' : 'text/x-vcard', 
  512.   '.wav' : 'audio/x-wav', 
  513.   '.wiz' : 'application/msword', 
  514.   '.wsdl' : 'application/xml', 
  515.   '.xbm' : 'image/x-xbitmap', 
  516.   '.xlb' : 'application/vnd.ms-excel', 
  517.   # Duplicates
  518.   '.xls' : 'application/excel', 
  519.   '.xls' : 'application/vnd.ms-excel', 
  520.   '.xml' : 'text/xml', 
  521.   '.xpdl' : 'application/xml', 
  522.   '.xpm' : 'image/x-xpixmap', 
  523.   '.xsl' : 'application/xml', 
  524.   '.xwd' : 'image/x-xwindowdump', 
  525.   '.zip' : 'application/zip', 
  526.   } 
  527.   
  528.  # These are non-standard types, commonly found in the wild. They will 
  529.  # only match if strict=0 flag is given to the API methods. 
  530.   
  531.  # Please sort these too 
  532.  common_types = { 
  533.   '.jpg' : 'image/jpg', 
  534.   '.mid' : 'audio/midi', 
  535.   '.midi': 'audio/midi', 
  536.   '.pct' : 'image/pict', 
  537.   '.pic' : 'image/pict', 
  538.   '.pict': 'image/pict', 
  539.   '.rtf' : 'application/rtf', 
  540.   '.xul' : 'text/xul' 
  541.   } 
  542.   
  543.   
  544. _default_mime_types() 
  545.   
  546.   
  547. if __name__ == '__main__': 
  548.  import getopt 
  549.   
  550.  USAGE = """\ 
  551. Usage: mimetypes.py [options] type 
  552.   
  553. Options: 
  554.  --help / -h  -- print this message and exit 
  555.  --lenient / -l -- additionally search of some common, but non-standard 
  556.        types. 
  557.  --extension / -e -- guess extension instead of type 
  558.   
  559. More than one type argument may be given. 
  560. """ 
  561.   
  562.  def usage(code, msg=''): 
  563.   print USAGE 
  564.   if msg: print msg 
  565.   sys.exit(code) 
  566.   
  567.  try: 
  568.   opts, args = getopt.getopt(sys.argv[1:], 'hle', 
  569.          ['help', 'lenient', 'extension']) 
  570.  except getopt.error, msg: 
  571.   usage(1, msg) 
  572.   
  573.  strict = 1 
  574.  extension = 0 
  575.  for opt, arg in opts: 
  576.   if opt in ('-h', '--help'): 
  577.    usage(0) 
  578.   elif opt in ('-l', '--lenient'): 
  579.    strict = 0 
  580.   elif opt in ('-e', '--extension'): 
  581.    extension = 1 
  582.  for gtype in args: 
  583.   if extension: 
  584.    guess = guess_extension(gtype, strict) 
  585.    if not guess: print "I don't know anything about type", gtype 
  586.    else: print guess 
  587.   else: 
  588.    guess, encoding = guess_type(gtype, strict) 
  589.    if not guess: print "I don't know anything about type", gtype 
  590.    else: print 'type:', guess, 'encoding:', encoding 
 

附上一篇关于python编码的帖子

1. pyhton的所有内置库、方法接受的是unicode编码的字符串。

2. str.decode 函数就是转成unicode编码，所以能decode的字符串传进python的内置库、函数都能正确运行。

3.问题在于这个decode函数解码时到底要传哪个参数：utf-8,gbk,gb2312......等N种编码。参数不当，就会抛类似异常：

 

复制代码 代码如下:
UnicodeDecodeError: 'gbk' codec can't decode bytes in position 2-3: illegal multibyte sequence

 

   UnicodeDecodeError: 'utf8' codec can't decode bytes in position 0-1: invalid data

 

下面举个例子：

  1. #coding:utf-8 
  2. #指定本文件编码为utf8 
  3. import os 
  4. # 以下为示例代码，不一定能运行。随意写的，无编译运行过。 
  5. # 例子以XP平台为例，因为linux平台编码（UTF-8）与window平台（GBK）不一样。 
  6. # 假设D盘下面有很多中文名称文件 
  7. filelist = os.listdir(r"d:\\") # 此处返回的list中的中文是以GBK编码的，你可以通过查看cmd窗口属性看到。 
  8. for path in filelist: 
  9.  if os.path.isdir(path): continue 
  10.   fp = open(path.decode("GBK") , 'rb') # 如果此处用 path.decode("UTF-8") 就会抛异常，原因是wind的dir命令返回的是GBK编码  
  11.  print len(fp.read()) 
  12.   fp.close() 
  13. filepath =r"d:\\中文文件.doc"    # 假设此文存在，记得要带中文 
  14. fp = open(filepath.decode('utf-8'), "rb") #这里使用utf8参数进行解码，原因是文件头里有句coding: utf-8 
  15. print len(fp.read()) 
  16. fp.close() 
  17. path2 = u"d:\\中文文件.doc" # 假如这里有个u在前面，这个变量就是unicode编码了，不用解码。 
  18. fp = open(path2, 'rb') 
  19. print len(fp.read()) 
  20. fp.close() 
标签：

相关文章