Python 开发中遇到的20个坑（总结篇）

‘’’
1 lambda 函数
2 生成器不保留迭代过后的结果
3 可变对象不能作为函数默认值
4 在循环中修改列表选项
5 列表取值超出索引数
6 重用全局变量
7 拷贝可变对象
8 Python 多继承
9 列表的 append 和 extend
10 datetime 布尔值
11 == & is 区别
12 copy deepcopy pickle
13 list 操作技巧
14 dict 操作技巧
15 Python yield
16 异常处理
17 Python 三种方法
18 Python 三器
19 属性监听
20 异步调用

‘’’

1

my_list = [lambda x: x*i for i in range(5)]
for m in my_list:
print(m(1)) # 4,4,4,4,4

输出[0,1,2,3,4] 方法一

my_list1 = [lambda x, i=i: x*i for i in range(5)]
for m in my_list1:
print(m(1))

方法二：生成器

my_gen = (lambda x: x*i for i in range(5))
for m in my_gen:
print(m(1))

方法三：将方法一改写为def函数，即闭包函数

def func():
lst = []
for i in range(5):
def bar(x, i=i):
return x*i
lst.append(bar)
return lst
for m in func():
print(m(1))

方法四：Zip()方法

def func(items, num):
return zip(*[iter(items)]*num)
print(func(range(9), 3))

2

gen = (i for i in range(5))
print(2 in gen) # True
print(3 in gen) # True
print(1 in gen) # False 调用1->2, 这时1不在genrater中，按循环顺序，按需生成

gen1 = (i for i in range(5))
lst = list(gen1)
print(2 in lst)
print(3 in lst)
print(1 in lst) # 均为 True，因为list会保存值，循环过，一样在

3

def foo(value, list=[]):
list.append(value)
return list
l1 = foo(1)
print(l1) # [1]
l2 = foo(2)
print(l2) # [1,2]

修改函数只取[2]

def foo1(value, num=None):
if num is None:
num = []
num.append(value)
return num
l1 = foo1(1)
print(l1) # [1]
l2 = foo1(2)
print(l2) # [2]

import time

def report_arg(_default=time.time()):
print(_default)
report_arg() # 1543575193.180959
time.sleep(2)
report_arg() # 1543575193.180959

字典，列表，集合等对象不适合做函数默认值，因为默认值会在函数建立时生成，每次都是调用了对象的 ‘缓存’

4

a = list(range(30))
for i in a:
if i%4 !=0:
a.remove(i)
print(a) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

import copy
a = list(range(30))
b = copy.deepcopy(a)
for i in a:
if i%4 !=0:
b.remove(i)
print(b) # [0, 4, 8, 12, 16, 20, 24, 28]

for in 是对下表进行操作，remove()是对值进行操作

5

lst = [1,2,3,4,5]

print(lst[5])

print(lst[5:]) # []

6

7

lst = [[1,2,3]] *2
lst2 = [[1,2,3] for i in range(2)]
print(lst)
print(lst2)

lst[1][0] = ‘a’
print(lst)
lst2 = [[1,2,3] for i in range(2)]
lst2[1][0] = ‘a’
print(lst2)

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

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

[[‘a’, 2, 3], [‘a’, 2, 3]]

[[1, 2, 3], [‘a’, 2, 3]]

拷贝可变对象，修改值是对象引用的操作，循环可生成不同的对象

8

class A(object):
def foo(self):
print(‘class A’)

class B(object):
def foo(self):
print(‘class B’)

class C(A, B):
pass
print(C().foo())

C继承了A,B 有结果即返回

print(’------------------------------’)
class A(object):
def foo(self):
print(‘class A’)

class B(A):
def foo(self):
pass

class C(A):
def foo(self):
print(‘class C’)

class D(B, C):
pass
print(D().foo())
print(D.mro)

(main.D’>, main.B’>, main.C’>, main.A’>, )

9

lst1 = list(range(30))
print(‘ID:’, id(lst1))

lst1 += [1]
print(‘ID(+=):’, id(lst1))

lst1 = lst1 + [2]
print(‘ID:’,id(lst1))

lst2 = []
print(id(lst2))

lst2.append(1)
print(id(lst2))

lst2.extend([1])
print(id(lst2))

10

import datetime

print(’“daetime.time(0,0,0)”(midnight) ->’, bool(datetime.time(0,0,0)))
print(’“datetime.time(1,0,0)” (1 am) ->’, bool(datetime.time(1,0,0)))

11

a = float(‘main’)
print(‘a is a’, a is a)

a = 1
b = 1
print(a is b)

c = -9
d = -9
print(bool(c is d))

a = ‘Hello world’
b = ‘Hello world’
print(a is b)
print(a == b)

a = float(‘1.22’)
print(a is a)
print(a == a)

is判断ID，==比较值； 小整数对象[-5, 256]

12

from copy import copy, deepcopy
from pickle import dumps, loads

a = [‘x’,‘y’,‘z’]
b = [a] * 3
c = copy(b)
d = deepcopy(b)
e = loads(dumps(b, 2))

b[1].append(999)
b.append(888)
c[1].append(999)
c.append(777)
d[1].append(999)
d.append(222)
e[1].append(999)
e.append(111)

print(a)
print(b)
print©
print(d)
print(e)

[‘x’, ‘y’, ‘z’, 999, 999]

[[‘x’, ‘y’, ‘z’, 999, 999], [‘x’, ‘y’, ‘z’, 999, 999], [‘x’, ‘y’, ‘z’, 999, 999], 888]

[[‘x’, ‘y’, ‘z’, 999, 999], [‘x’, ‘y’, ‘z’, 999, 999], [‘x’, ‘y’, ‘z’, 999, 999], 777]

[[‘x’, ‘y’, ‘z’, 999], [‘x’, ‘y’, ‘z’, 999], [‘x’, ‘y’, ‘z’, 999], 222]

[[‘x’, ‘y’, ‘z’, 999], [‘x’, ‘y’, ‘z’, 999], [‘x’, ‘y’, ‘z’, 999], 111]

a 列表赋值给 b，b[1].append(999),此时a = [‘x’, ‘y’, ‘z’, 999]

b 又被 c浅拷贝，最终 a = [‘x’, ‘y’, ‘z’, 999, 999]

b[1] 中三个子列表指向同一个内存地址，即对 a 的引用

13

l1 = [‘a’,‘b’,‘c’]
l2 = list(range(10))

print(l1+l2)

+ 合并列表资源浪费，会重新创建一个列表，复制完成合并

l3 = [77,88]
l4 = l3.extend(l2)
print(l3)

数据类型相同，推荐使用extend()函数

l5 = [‘a’,‘hh345’,‘gg12’,‘ff123’,‘vv4444’,‘nn33333’]
print(l5.sort(key=lambda x: x[0], reverse=True))
l6 = [i for i in range(10)]
print(l6[:5:2])
print(l6[::-1])

l7 = [‘zhang’,‘wang’,‘lee’]
ma = dict((v,i) for i, v in enumerate(l7))
print(ma)

enumerate 函数返回（index，value）元祖

l8 = sorted([‘r’,‘e’,‘d’,‘f’])
l9 = sorted(‘hello python’)
print(set(l9))

sorted和set合用，生成唯一元素有序列表

seq1 = [‘zhang’,‘wang’,‘lee’]
seq2 = [‘san’,‘si’,‘wu’]
for i, (a,b) in enumerate(zip(seq1, seq2)):
print(’%d: %s %s’ % (i, a, b))

enumerate和zip 函数合用，压缩序列

seq3 = [(‘a’,‘b’),
(‘c’,‘d’),
(111, 22)]
m, n = zip(*seq3)
print(m,n)

列元素转为行，行元素转为列

14

dict1 = {‘k’: ‘abc’, ‘v’:‘123’}
dict2 = {v : k for k, v in dict1.items()}
print(dict2)

K-V 互换

dict3 = {‘a’:12,‘b’:22,‘c’:22,‘d’:14,‘e’:6,‘f’:77}
dict4 = sorted(dict3.items(), key=lambda item: -item[1])
print(dict4)

字典值降序输出

dict5 = sorted(zip(dict3.values(), dict3.keys()))
print(dict5)

zip() 函数会对第一个元素进行排序

15

def func(n):
for i in range(n):
yield call(i)
print(‘i=’, i)
print(‘this is a test…’)

def call(i):
return i*2
for i in func(5):
print(i, ‘,’)

16

def func():
try:
print(‘one:’)
except IndexError:
print(‘rasised IndexError’)
else:
print(‘No error in try-block’)
func()

for i in range(5):
print(i)
else:
print(‘compleled for-loop’)
for i in range(2):
print(i)
i += 1
break
else:
print(‘completed for-loop’)

17

class Fib:
‘’’ 迭代器实现斐波那契数列 ‘’’
def init(self, max_vlaue):
self.prev = 0
self.curr = 1
self.max_value = max_vlaue
def iter(self):
return self
def next(self):
if self.curr <= self.max_value:
res = self.curr
self.prev, self.curr = self.curr, self.prev + self.curr
return res
else:
raise StopIteration()
print(Fib(5))

def fib(max_value):
‘’’ 生成器实现斐波那契数列 ‘’’
prev, curr = 0, 1
while curr <= max_value:
yield curr
prev, curr = curr, prev + curr
fib(5)

def deco(func):
‘’’ 最简单装饰器 ‘’’
def wra(*args, **kwaegs):
return func()
return wra

import datetime

def count_time(func):
‘’’ 函数运行时间 ‘’’
def wra(*args, **kwargs):
start_time = datetime.datetime.now()
func()
end_time = datetime.datetime.now()
total_time = (end_time - start_time).total_seconds()
print(‘time is %s seconds’ % total_time)
return wra

@count_time
def main():
print(’>>>Time is start : ')
for i in range(10):
for j in range(i):
print(j)

if name == ‘main’:
main()

import time

class Retry(object):
‘’’ 最大连接次数 ‘’’
def init(self, max_retries=3, wait=0, exceptions=(Exception, )):
self.max_retries = max_retries
self.exceptions = exceptions
self.wait = wait

def __call__(self, func):
    def wrap(*args, **kwaegs):
        for i in range(self.max_retries + 1):
            try:
                res = func(*args, **kwaegs)
            except self.exceptions:
                time.sleep(self.wait)
                continue
            else:
                return res
    return wrap

18

class Method(object):
x = 666

def __init__(self):
    self.y = 777

def bar1(self):
    print('a method')

@classmethod
def bar2(cls):
    print('a classmethod')

@staticmethod
def bar3():
    print('a staticmethod')

def func1(self):
    print(self.x)
    print(self.y)
    self.bar1()
    self.bar2()
    self.bar3()

@classmethod
def func2(cls):
    print(cls.x)
    print(cls.y)
    cls.func1()
    cls.func2()
    cls.func3()

@staticmethod
def func3(obj):
    print(obj.x)
    print(obj.y)
    obj.func1()
    obj.func2()
    obj.func3()

m = Method()
m.func1()
m.func2()
m.func3()

19

class User:
‘’’ 属性监听 ‘’’
#q = [i for i in range(10000)]
q = [1,2,3]
def init(self):
self.money = 100000
self.name = ‘lee’

def __setattr__(self, name, value):
    if name == 'money' and value < 0:
        raise ValueError('money < 0')
    print('set %s to %s' % (name, value))
    object.__setattr__(self, name, value)

def __getattribute__(self, name):
    print('get %s ' % name)
    return object.__getattribute__(self, name)
    
def func(x, y):
    return x ** y

a = User()
print(User.dict)
print(a.dict)

20

from functools import wraps
import time
import threading

def deco(func):
@wraps(func)
def wrap(*args, **kwargs):
my_thread = threading.Thread(target=func, args=args, kwargs=kwargs)
my_thread.start()
return wrap

@deco
def foo(x, y):
t = 0
while t < 10:
t += 1
print(‘x:{}, y:{}’.format(x, y))
time.sleep(2)
foo(666, 999)