Python2.7三种编码设置的区别及相关报错疑问

Hey there, let's unpack these three Python 2.7 encoding settings and your questions—they're some of the most confusing parts of Python 2's string handling, so you're not alone here!

First, let's clarify what each setting actually does: #

• # -*- coding: utf-8 -*- (File Encoding)
  This line tells the Python interpreter: "Hey, this source file is saved in UTF-8 encoding." When the interpreter reads your code, it uses UTF-8 to convert the raw bytes in the file into Unicode characters. Without this, Python 2 defaults to ASCII—so if your file has any non-ASCII characters (like Chinese), it'll throw a syntax error immediately. This only affects how the interpreter parses the source file itself—it doesn't change how strings behave once they're in memory.

• from __future__ import unicode_literals (String Literal Type)
  In Python 2, regular string literals like "hello" are str objects (byte strings), and you need the u prefix (u"hello") to get a unicode object (the actual Unicode character sequence). This import flips that behavior: after importing, all un-prefixed strings become unicode objects by default. This changes the default type of your string literals in code, but it doesn't affect how existing strings (like data from databases, user input, or external files) are handled.

• sys.setdefaultencoding('utf8')
  Python 2 has a hidden gotcha: when you mix str and unicode objects (e.g., concatenating them, passing a unicode to a function expecting a str), it automatically tries to convert the unicode to a str using the default encoding. By default, this encoding is ASCII. If your unicode has characters outside ASCII (like your "emcms外贸网站管理系统"), this conversion fails with the UnicodeEncodeError you saw.
  This line overrides that default encoding to UTF-8, so the implicit conversion uses UTF-8 instead of ASCII, avoiding the error. Important note: Python 2 intentionally hides this method (you have to reload sys to even access it in some cases) because relying on implicit conversions makes code hard to debug. It's a quick fix, not a long-term solution—ideally, you'd explicitly convert strings to the correct type instead.

Answering your specific questions: #

1. Why do I need the string encoding setting if I already set the file encoding? #

These two settings handle completely separate stages:

• The file encoding (# -*- coding: utf-8 -*-) ensures the interpreter correctly reads the bytes in your source file into characters. For example, without it, the bytes for "中文" in your UTF-8 saved file would be misinterpreted as ASCII garbage, causing a syntax error.
• The unicode_literals import changes what type your string literals are. Even with the file encoding set, a plain "中文" would be a UTF-8 encoded str (byte string) without this import. With it, it becomes a unicode object (the actual character sequence).
  Think of it this way: file encoding is about reading the code correctly, string literal setting is about what kind of string objects you create when you write quotes in your code.

2. Why do I still get UnicodeEncodeError after setting both? #

Because the error isn't coming from your source file or string literals—it's coming from implicit conversions between str and unicode elsewhere in your code (or Django's internals). For example:

• Maybe your Django app is pulling a unicode string from the database, and then passing it to a function that expects a str byte string.
• Or somewhere in the code, a str (byte string) is being concatenated with a unicode string.

In these cases, Python 2 tries to convert the unicode to str using the default ASCII encoding, which fails for non-ASCII characters. The sys.setdefaultencoding('utf8') fixes this by making the implicit conversion use UTF-8 instead of ASCII.

内容的提问来源于stack exchange，提问作者Alvin