27 个为什么，帮助你更好的理解Python

01. 为什么使用缩进来分组语句？

if (x <= y)	
        x++;	
        y--;	
z++;

02. 为什么简单的算术运算得到奇怪的结果？

03. 为什么浮点计算不准确？

>>> 1.2 - 1.0	
0.19999999999999996

04. 为什么 Python 字符串是不可变的？

05. 为什么必须在方法定义和调用中显式使用“self”？

06. 为什么不能在表达式中赋值？

while (line = readline(f)) {	
    // do something with line	
}

while True:	
    line = f.readline()	
    if not line:	
        break	
    ...  # do something with line

if (x = 0) {	
    // error handling	
}	
else {	
    // code that only works for nonzero x	
}

line = f.readline()	
while line:	
    ...  # do something with line...	
    line = f.readline()

for line in f:	
    ...  # do something with line...

07 为什么 Python 对某些功能（例如 list.index()）使用方法来实现，而其他功能（例如 len(List)）使用函数实现？

08. 为什么 join()是一个字符串方法而不是列表或元组方法？

09. 异常有多快？

try:	
    value = mydict[key]	
except KeyError:	
    mydict[key] = getvalue(key)	
    value = mydict[key]

if key in mydict:	
    value = mydict[key]	
else:	
    value = mydict[key] = getvalue(key)

10. 为什么 Python 中没有 switch 或 case 语句？

def function_1(...):	
    ...	

	
functions = {'a': function_1,	
             'b': function_2,	
             'c': self.method_1, ...}	

	
func = functions[value]	
func()

def visit_a(self, ...):	
    ...	
...	

	
def dispatch(self, value):	
    method_name = 'visit_' + str(value)	
    method = getattr(self, method_name)	
    method()

11. 难道不能在解释器中模拟线程，而非得依赖特定于操作系统的线程实现吗？

12. 为什么 lambda 表达式不包含语句？

13. 可以将 Python 编译为机器代码，C 或其他语言吗？

14. Python 如何管理内存？

for file in very_long_list_of_files:	
    f = open(file)	
    c = f.read(1)

for file in very_long_list_of_files:	
    with open(file) as f:	
        c = f.read(1)

15. 为什么 CPython 不使用更传统的垃圾回收方案？

16. CPython 退出时为什么不释放所有内存？

17. 为什么有单独的元组和列表数据类型？

18. 列表如何在 CPython 中实现？

19. 字典如何在 CPython 中实现？

20. 为什么字典 key 必须是不可变的？

• 哈希按其地址（对象 ID）列出。这不起作用，因为如果你构造一个具有相同值的新列表，它将无法找到；例如:
  会引发一个 KeyError 异常，因为第二行中使用的  [1, 2]  的 id 与第一行中的 id 不同。换句话说，应该使用  ==  来比较字典键，而不是使用 is 。
• 使用列表作为键时进行复制。这没有用的，因为作为可变对象的列表可以包含对自身的引用，然后复制代码将进入无限循环。
• 允许列表作为键，但告诉用户不要修改它们。当你意外忘记或修改列表时，这将产生程序中的一类难以跟踪的错误。它还使一个重要的字典不变量无效： d.keys()  中的每个值都可用作字典的键。
• 将列表用作字典键后，应标记为其只读。问题是，它不仅仅是可以改变其值的顶级对象；你可以使用包含列表作为键的元组。将任何内容作为键关联到字典中都需要将从那里可到达的所有对象标记为只读 —— 并且自引用对象可能会导致无限循环。

class ListWrapper:	
    def __init__(self, the_list):	
        self.the_list = the_list	

	
    def __eq__(self, other):	
        return self.the_list == other.the_list	

	
    def __hash__(self):	
        l = self.the_list	
        result = 98767 - len(l)*555	
        for i, el in enumerate(l):	
            try:	
                result = result + (hash(el) % 9999999) * 1001 + i	
            except Exception:	
                result = (result % 7777777) + i * 333	
        return result

21. 为什么 list.sort() 没有返回排序列表？

for key in sorted(mydict):	
    ...  # do whatever with mydict[key]...

22. 如何在 Python 中指定和实施接口规范？

23. 为什么没有 goto？

class label(Exception): pass  # declare a label	

	
try:	
    ...	
    if condition: raise label()  # goto label	
    ...	
except label:  # where to goto	
    pass	
...

24. 为什么原始字符串（r-strings）不能以反斜杠结尾？

dir = r"\this\is\my\dos\dir" "\\"	
dir = r"\this\is\my\dos\dir\ "[:-1]	
dir = "\\this\\is\\my\\dos\\dir\\"

25. 为什么 Python 没有属性赋值的“with”语句？

with obj:	
    a = 1               # equivalent to obj.a = 1	
    total = total + 1   # obj.total = obj.total + 1

def foo(a):	
    with a:	
        print(x)

function(args).mydict[index][index].a = 21	
function(args).mydict[index][index].b = 42	
function(args).mydict[index][index].c = 63

ref = function(args).mydict[index][index]	
ref.a = 21	
ref.b = 42	
ref.c = 63

26. 为什么 if/while/def/class 语句需要冒号？

if a == b	
    print(a)

if a == b:	
    print(a)

27. 为什么 Python 在列表和元组的末尾允许使用逗号？

[1, 2, 3,]	
('a', 'b', 'c',)	
d = {	
    "A": [1, 5],	
    "B": [6, 7],  # last trailing comma is optional but good style	
}

x = [	
  "fee",	
  "fie"	
  "foo",	
  "fum"	
]