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

小灰灰 2022-04-12 06:09 225阅读 0赞

‘’’  
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\]\] #

# \[\[‘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**)

# (<class ‘**main**.D’>, <class ‘**main**.B’>, <class ‘**main**.C’>, <class ‘**main**.A’>, <class ‘object’>) #

# 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)

[self.name]: http://self.name