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

[cxa]

说一说 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 学习开发。

#补充 lambda 闭包的那个例子，正确方式:
ls = []
for i in range(5):
ls.append(lambda i=i: i**2)
print(ls[0]())
print(ls[1]())
print(ls[2]())

[zhuangzhuang1988]

还是直接换语言吧.

[di94sh]

针对函数默认参数的问题, 我感觉只解释可变对象, 非常的 naive

[看看我的解释]( https://crowser.me/2018/08/23/2018/%E6%8E%A2%E7%B4%A2-Python-%E5%87%BD%E6%95%B0%E5%AF%B9%E8%B1%A1%E5%8F%82%E6%95%B0%E9%BB%98%E8%AE%A4%E5%80%BC%E9%99%B7%E9%98%B1/)

[lihongjie0209]

写小脚本的不在意这些, 写大项目的要更强大的约束

[ddzzhen]

支持一下

[CODEWEA]

换 php 吧

[Mirage09]

要看坑的话，看这个：
https://github.com/satwikkansal/wtfpython

[Kylin30]

换职业吧

[findex]

换 c++吧

[q397064399]

避免这些坑的做法就是先学习一门强类型编程语言，等你玩溜了强类型 再回来用 Python 就明白 Python 为什么要这样，强类型解决了哪些问题，同时强类型跟弱类型各自又有哪些缺陷，怎么做才能更好避免这些问题。

我一直说 Python 是编程老师傅手上的玩具，不是入门菜鸟的导师工具，业界在吹 Python 适合入门简直就坑人。

新手连类型系统都搞不清楚，就开始编程，能组织 5000 行代码 并不断维护这些代码 你就烧高香吧。

[janxin]

执行文件路径和当前路径这个不是是个程序就会有的问题吗...

[wzw]

@q397064399 #9 能写 5w 行，还能维护，算不算过关😄

[XIVN1987]

惰性求值只说了问题，，没说解决方法啊：
ls = []
for x in range(5): ls.append(lambda x=x: x**2)
print(ls[0]())
print(ls[1]())
print(ls[2]())

输出：
0
1
4

[swulling]

@q397064399 Python 也是强类型

[zxcvsh]

如果你一定要在自己不明白的时候这样写就加上地址判断；熟悉了规则机制后，你都可以当全局变量用了

[Wincer]

@q397064399 Python 是动态强类型，谢谢

[www5070504]

有些是基础就该知道的 另外我感觉这种公众号文章就别复制粘贴了 这种文章已经到处都是了

[zxcvsh]

@Wincer js 才是弱类型，当初第一次用的时候，一个 if 判断，变量值都变了，我才知道 == 和 ===
被自己蠢哭

[berretta]

写了五六年 python，有些语法从来没写过

[hsfzxjy]

建议用 if x is None 判断对象是不是 None，很多时候 None 带有缺失值的语义

[trait]

楼上应该是混淆了 strong vs weak, static vs dyn，当然这种情况也不好说什么，毕竟清北 c9 以下的大多数码农培训班都不会，也没能力开设 PL 基础课程
go/rust 出生的 2010 年前后，工业界面对暴涨的业务需求和摩尔定律停滞终于想起了学术界早就研究出来几十年的东西，现在的大多数技术不过是在炒冷饭，python 这些动态老牛车不过是乘着摩尔东风和暂且少量的数据和代码要求才这么火，这些破车等到下一个“摩尔”可能还有机会

[hsfzxjy]

闭包那个，表达式任何时候都是立即求值的。

问题的关键在于分清函数定义时和执行时两个阶段。Python 使用词法作用域，这点和其他大部分语言一样，闭包只捕获了名称。而循环体不构成作用域，因此所有的 x 其实指向的是同一个名称。

如果熟悉 js，也可以用 IIFE 解决

```python
for x in range(5):
ls.append((lambda x: lambda: x**2)(x))
```

[Sparetire]

python 是动态类型强类型吧。。上面的自己都没搞清楚。。

[susecjh]

这些基础算坑？

[cyspy]

Python 虽然是强类型，但是太动态了，函数参数判断类型的乏力导致确实不容易在入门时理解类型

[tanpengsccd]

正在学习

[reself]

@q397064399 py 是强类型

[q397064399]

@reself
@CODEWEA
@Wincer
@trait

好，知道了，强弱只是一个概念，我这里只是弄错了一个说法，之前看过相关的描述，记不清动态强弱的概念了

从静态分析的角度 出发 Python 就是弱得一逼，所有的方法调用都要靠运行时来保证
想不出错，写三行代码 要跑好 10 次 debug 来保证方法的参数 输入正确，这对新手来说是致命的

另外我强调的是静态类型系统 重要的事情说三遍，没有静态分析的语言的类型系统只适合编程老师傅，
因为这些类型问题全部都要靠运行时来保证。

而且这些语言 在静态分析的情况下 ，你根本无法得到一个清晰且完整的数据结构，
有一定经验的人都知道，你数据结构 在代码定义清楚了，代码基本上不用看 也大致明白是怎么一回事。

[q397064399]

@Sparetire

[zh826256645]

requests 不支持自动解压网站的 br 压缩格式

[Nicoco]

@wzw html && css && xml ?

[qile1]

问题。 上面代码简化为:

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)

我就是一个个赋值的

[no1xsyzy]

@q397064399
你要的只是静态类型系统吗？隐式静态弱类型也能用吗（类型只写 auto 就是了）？我不觉得静态是重点，我觉得显式是重点，运行时不管你类型对不对，只要全都标出来就行了，Python + 匈牙利命名法（虽然你能找到的基本是误用，我说的也就是那个误用）就行了，不必找其他语言。
印证了那句老话。
> 程序写出来是给人看的，只是顺便能在机器上运行。
说真的，要搞清楚类型系统，自己写一个是最好的。

[no1xsyzy]

@XIVN1987 这个 x=x 学到了，我只想到重传一层闭包

[q397064399]

@no1xsyzy #32 你这里弄错了我的意思，我举个简单的例子 Python3 很多库是没有 返回类型标识的，只有运行的时候才能搞清楚返回的数据结构， 像 openpyxl 读写 excel 文件的 API，它返回的 层级结构 是 file -> worksheet -> rows -> cell ,其中每个 cell 还对应字体颜色 单元格样式 等等，
这个返回的数据结构 至少有 5 层，但是只有运行时你才能看到，对应方法上的 API 就是寥寥数行说明文字，这还是比较规范的，如果是多人合作，你只能向上帝祈祷它返回的数据结构是你想要的那个样子，即使你加上一大堆的 assert 类型校验什么的，还是无法解决这个问题。

另外在编写 Python 代码的时候 你需要时不时回头看下这个 API 返回的类型的层级结构，去其中找到你需要的数据，这是一件非常累人的事情， 但是像 Java 自带静态分析 还有显示类型标注，几乎不存在这样的问题。另外就是方法的传参

[ctro15547]

用 python 时候做好习惯写说明的习惯，在方法里写好参数和返回值的类型、结构等，这样可以 help()来查看，就不用回头去看之前写的方法参数和返回值是啥。跟别人合作能这么做比较好，自己用随便啦大不了 int （） str （）用起来

[xrlin]

这些都是很基础的问题

[xrlin]

@cyspy 你用下 ruby 就会觉得 python 真的很保守了

[ytmsdy]

用 python 当新手入门语言确实不合适，
新手入门还是用强类型的语言比较好。
要不然一上来各种花式语法，很容易蒙的！

[ballshapesdsd]

直接拉到下面看公众号

[Yalaster]

没怎么写过 py，不过真的有人写出来 def foo(num,age=[])这种东西吗，看着都难受啊。

[reself]

@q397064399 所以还是至少学一门静态学一门动态。静态有时候太束缚，动态又容易失控。使用动态语言但借鉴静态语言的一些约定是不错的思路。

[no1xsyzy]

@q397064399 这反而回到工具问题了。其实如果说不是太依赖鸭子属性，完全可以产生一个运行时来动态地写。
比如 foo.bar 和 foo.baz ，把运行到某一行的状态 cache 起来，接下来一行打出 foo. 的时候就能直接提示后面可能是 foo.bar foo.baz foo.__dict__ 什么的。而且如果不是重度依赖鸭子性，静态分析也是可能的。类型标记递归更新。
比如，Atom 的自动补全可以解决很多问题了。但是永远会跑满一个核心……

[bugcoder]

```
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 3.7 的 dataclass 了解一下

[anonymous256]

第一个坑完全不是坑，传参数用列表就是为了方便使用或者修改它。你既然用了 append 修改它，又不希望原列表被改动，这是什么道理呢？

如果你实在不想修改它，你完全可以把列表的副本传进去。
def foo(num,age[:]): <—— 写成切片就可以了，其它不需要改动

当然，你也可以学 golang，它的 append 不会改变列表

[anonymous256]

2. 字典赋值
这个问题纯粹是无稽之谈，①把非 str 类型作为字典的键，本身就是一个好做法 ②你的键混用了 int 和 float 两种数据结构，甚至还想把 bool 值做为 key，这个做法更离谱了。

3. if a:
a 如果是 [None，空字符串""，空列表[]，空字典｛｝] ，这完全是一个十分优雅的设计，尤其当你的函数需要返回诸如一个 list 时，只需要 if 它就行就行下一步处理，这么做的好处是不用处理空值或 None 的这种异常行为。

如果你希望判断 None，请务必写成 if a is None:

[anonymous256]

本身就是一个好做法 ----> 本身就不是一个好做法。

字典是一种映射类型，大多数编程实践，map 的 key 以字符串或 int 为主，而且我从不会在代码中混用两种数据结构作为 key，更没见过有人会把 key 使用两种截然不同的数据结构。楼主的观点漏洞太多。

[operawang]

变量名写错了都不知道。

[qdzzyb]

https://github.com/leisurelicht/wtfpython-cn