Python 中的这些坑，早看早避免。

说一说 python 中遇到的坑，躲坑看这一篇就够了

传递参数时候不要使用列表

def foo(num,age=[]):
	age.append(num)
	print("num",num)
	return age
print(foo(1))
print(foo(2))
print(foo(3))

上面的代码输出的结果并不是我们预期的那样，打印出三个数组[1],[2],[3]。 而是下面这样.

num 1
[1]
num 2
[1, 2]
num 3
[1, 2, 3]

为什么会这样呢，原因就是参数 age 是一个列表，列表是一个可变对象，同时在作为函数参数时，相当于全局变量，在函数预处理时就已经分配了内存空间。那么我们如何修改呢？ 其实很简单只要不让列表参数作为列表，一般可变类型对象作为参数的时候默认都是给定 None，然后根据对象判断是否为空，如果为空再去定义成列表，修改如下：

def foo(num, age=None):
    if not age:
        age = []
    age.append(num)
    print("num", num)
    return age
print(foo(1))
print(foo(2))
print(foo(3))

for。。。else 的使用场景

在刷 pythontip 的时候遇到这道题，觉得很有必要和大家普及下 for。。else 的用处，好了下面我们开始： 输出 100 以内的所有素数，素数之间以一个空格区分（注意，最后一个数字之后不能有空格）。

#在一般领域，对正整数 n，如果用 2 到根号 N 之间的所有整数去除，均无法整除，则 n 为质数又叫素数。
import math
num = [] #存放 1-100 之间的素数
for i in range(2, 100):
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
break
else:
num.append(i) #根据定义如果都无法正常才加入
for index, i in enumerate(num):
if index == len(num) - 1:
print(i)
else:
print(i, end=" ")

根据关键语句「所有整数去除，均无法整除，则 n 为质数又叫素数。」，转化成程序也就是说在所有的的数字都循环完了，还不能出才作为质数，也就是最后的那个 else，体现了这句话。由此可以看出 for。。else 还是挺重要的。

字典赋值

看下面的代码，猜想输出结果：

a = {}
a[1] = "A"
a[1.0] = "B"
a[2] = "C"
print(a)

如果不知道字典里的键和 hash 有关，就不会知道结果是下面这个样子

{1: 'B', 2: 'C'}

这是为什么呢？ 因为，Python 中的字典是通过检查键值是否相等以及哈希值来确定两个键是否相同. 具有相同值的不可变对象在 Python 中始终具有相同的哈希值. 因为 1=1.0 所以 hash(1)==hash(1.0).同样的我们知道 python 中的 true 相等，我们试着 计算其 hash 值可以看到 hash(1)==hash(True)。 由此我们可以得到如下等式：

hash(1)==hash(1.0)==hash(True)

因为只不可变对象才存在 hash 值所以 hash([])不存在。同样我们可以推断出

hash(0) == hash(False) == hash("")

根据 PEP285 中 Review 部分第 6 条所述，bool 类其实是从 int 类继承而来.

print(isinstance(True, int))

关于 if 判断条件正确写法

python3 中 0=[]=()={}=None=False="",所以当我们在判断列表，或者字典字符串是否为空的时候不用再使用 a==None，这样的语句了。

a=[]
b={}
c=""
if not a:
   print("a 不为空")
if not b:
   print("b 不为空")
if not c:
   print("c 不为空")

同样的代码少写

一般我们写 if 判断的时候,我们都写成下面这种形式：

if type == "A":
    print(1)
elif type == "B":
    print(2)

像这样的我们需要写好多重复代码的程序，此时就要考虑是否优化了，针对这种情况我们可以优先考虑字典。

my_dict = {"A":1, "B":2}  #etc
print(my_dict[type])

另外我们在使用给对象的属性赋值的时候

class A():
    def __init__(self,dicts):
        self.name=dicts["name"]
        self.age=dicts["age"]
        self.sex=dicts["sex"]
        self.hobby=dicts["hobby"]
if __name__ == '__main__':
     dicts={"name":"lisa","age":23,"sex":"women","hobby":"hardstyle"}
     a=A(dicts)

我们看到我们需要换取传入的字典的各个键值，并创建键值同名一个属性，这里我们只有 4 个还好，想象一下如果我们传入的字典有 100 个键。。。如何还是这样一个一个赋值不敢想不敢想，人家都写完代码了，你还在赋值有木有。。 其实一开始的那段代码已经给出了答案，如果不会也没关系， 下面我们就来点 pythonic 的 python。来解决这个问题。 上面代码简化为:

class A():
    def __init__(self,dicts):
        self.__dict__.update(dicts)
        print(self.__dict__)
if name == ‘main’:
dicts={“name”:“lisa”,“age”:23,“sex”:“women”,“hobby”:“hardstyle”}
a=A(dicts)

小心闭包中的坑,python 的惰性计算

我们观察下面的代码

ls = []
for x in range(5):
    ls.append(lambda: x**2)
print(ls[0]())
print(ls[1]())
print(ls[2]())

我们以为它会输出[0],[1],[4].但实际情况是。。。。。

16
16
16

这是什么鬼？ 其实这和 python 的惰性求值有关。惰性求值，也就是延迟求值，表达式不会在它被绑定到变量之后就立即求值，而是等用到时再求值。x 实际不在 lambda 的作用域中。只有当 lambda 被调用时，x 的值才会被传给它。也就是最后的一次循环中 x 为 4，后面的 ls[1],ls[1],ls[2],ls[3]实际都是 16。同时这是面试常考的一个点，希望大家牢记。 这个问题考察了闭包。

执行文件路径和当前路径

执行文件的路径和当前的路径这是两个概念 获取文件的当前路径时可以的使用

import os
os.getcwd()

但是在需要执行的文件的获取其执行路径的时候就最好不要用这个了。 一般使用下面这种方式，动态的获取路径

import sys
sys.path[0]

###使用 eval 转整的时候数字前不能有 0

eval("02")

会发生错误：

Traceback (most recent call last):
  File "/demo/1.py", line 1, in <module>
    eval("02")
  File "<string>", line 1
    02
     ^
SyntaxError: invalid token

While 1 比 While True 快？

python2 的时候是这样，以为 python3 True=1 所以结果实际是一样的。 由于 Python2 中，True/False 不是关键字，因此我们可以对其进行任意的赋值，这就导致程序在每次循环时都需要对 True/False 的值进行检查；而对于 1，则被程序进行了优化，而后不会再进行检查。 Python3 中，由于 True/False 已经是关键字了，不允许进行重新赋值，因此，其执行结果与 while 1 不再有区别

处理长的字符串

对于长的字符串我们一般使用"""多文本"""的形式，但是换行的时候容易导致哪里出错，此时可以考虑在外面加个小括号，像这样

("""多文本""")

关于 requests 模块的编码问题

作者实际上提供了个自动识别网页编码的代码,在获取 res(请求的对象),获取源码之前使用 下面的代码即可获取正确的网站编码。

res.encoding=res.apparent_encoding

更多工具使用以及 python 技巧，请关注公众号：python 学习开发。