5个python中编程的大坑

一切都是借口

对于Python新手来说，写代码很少考虑代码的效率和简洁性，因此容易造成代码冗长、执行慢，这些都是需要改进的地方。本文是想通过几个案列给新手一点启发，怎样写python代码更优雅。
大坑一：不喜欢使用高级数据结构

1.sets（集合）

很多新手忽视sets（集合）和tuple（元组）的强大之处
例如，取两个列表交集：

1. def common_elements(list1, list2):   
2.     common = []        
3.     for item1 in list1:               
4.         if item1 in list2:                        
5.             common.append( item1 )        、
6.     return common

复制代码

这样写会更好：

1. def common_elements(list1, list2):
2.     common = set(list1).intersection(set(list2))
3.     return list(common)

复制代码

2.dic（字典）

新手枚举（访问和取出）字典的键和对应值，认为对应值必须通过键来访问，往往会这样做：

1. my_dict = {'a':1,'b':2}
2. for key in my_dict:        
3.     print(key, my_dict[key])

复制代码

有一个更优雅的方法可以实现：

1. my_dict = {'a':1,'b':2}
2.     for key, value in my_dict.items():   
3.     print(key, value)

复制代码

对大部分项目来说，这样写会更加有效率。
3.tuple（元组)

元组一旦创建就无法更改元素，看似没有什么用处，其实元组的作用大着呢！很多函数方法都会返回元组，比如enumerate()和dict.items()，并且可以在函数中使用元组，返回多个值。还能够很方便地从元组中提取信息：

1. a,b = ('cat','dog')

复制代码

上面元组中有两个元素，分别被赋给a，b。如果有多个值，同样可以提取：

1. a,b,c = ('cat','dog','tiger')
2. print(a,b,c)

复制代码

提取首、尾两个元素：

1. first,*_,end = (1,2,3,4,5,6)
2. print(first,end)
3. # 输出：1、6

复制代码

提取首、中、尾三部分：

1. first,*middle,end = (1,2,3,4,5,6)
2. print(first,middle,end)
3. # 输出：1、[2, 3, 4, 5]、6

复制代码

元组还可以用来交换变量：

1. (a,b,c) = (c,a,b)

复制代码

上面a变成之前的c，b变成之前的a，c变成之前的b
元组也能作为字典的键，所以如果你需要存储数据，可以使用带有元组键的字典，比如说经纬度数据。
大坑二：不喜欢使用上下文管理器

新手可能会习惯这样进行读取文件操作：

1. if os.path.exists(data_file_path):   
2.     data_file = open(data_file_path,'r')
3. else:   
4.     raise OSERROR
5. print( data_file.read())
6. data.close()

复制代码

这样写会有几个明显的问题：

• 可能出现文件存在，但文件被占用，无法读取的情况
  
• 可能出现文件可以被读取，但操作文件对象出现报错的情况
  
• 可能出现忘记关闭文件的情况
  

如果使用with...语句，问题就迎刃而解了：

1. with open(data_file_path,'r') as data_file:
2.     print(data_file.read)

复制代码

这样可以捕获任何打开文件或处理数据时的异常情况，并且在任务处理完后自动关闭文件。
python初学者可能不太了解上下文管理器的神奇之处，它真的能带来巨大的便利。
大坑三：不喜欢使用标准库

标准库itertools和collections仍然很少被初学者使用

1. itertools

复制代码

如果你看到下面的任务：

1. list1 = range(1,10)
2. list2 = range(10,20)
3. for item1 in list1:
4.     for item2 in list1:
5.         print(item1*item2)

复制代码

这是一个嵌套循环操作，为提高代码效率，完全可以用product()函数替代嵌套循环：

1. from itertools import product
2. list1 = range(1,10)
3. list2 = range(10,20)
4. for item1,item2 in product(list1, list2):
5.     print(item1*item2)

复制代码

这两段代码的结果完全一样，但使用标准库函数明显更加简洁高效。itertools还有很多方便操作迭代对象的函数，比如：

• count()函数会创建一个无限迭代器
  
• cycle()函数会把传入的序列无限重复下去
  
• chain()可以把多个迭代对象串联起来
  
• group()函数可以把迭代其中相邻的重复元素挑出来，放在一起
  ......
  

有兴趣可以详细看看itertools库的各种神奇函数
collections
新手对python集合模块了解的可能并不多，你可能会遇到这样的情形：

1. consolidated_list = [('a',1),('b',2),('c',3),('b',4)]
2. items_by_id = {}
3. for id_, item in consolidated_list:
4.     if id_ not in items_by_id:
5.         items_by_id[id_] = []
6.     if id_ in items_by_id:
7.         items_by_id[id_].append(item)

复制代码

上面代码构建了一个字典，依次向字典中添加信息，如果某个键已经存在，则以某种方式修改该键的值；如果某个键不存在，则添加对应键值对。
这种算法非常常见，你可以用collects模块的defaultdict()函数来实现同样效果：

1. from collections import defaultdict
3. items_by_id = defaultdict(list)
4. consolidated_list = [('a',1),('b',2),('c',3),('b',4)]
6. for id_, item in consolidated_list:
7.     items_by_id[id_].append(item)

复制代码

在此列中，defaultdict()接受一个list作为参数，当键不存在时，则返回一个空列表作为对应值。
有时候我们会遇到统计词频的案例，比如：

1. # 统计词频
2. colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
3. result = {}
4. for color in colors:
5.     if result.get(color)==None:
6.         result[color]=1
7.     else:
8.         result[color]+=1
9. print (result)
10. # 输出 {'red': 2, 'blue': 3, 'green': 1}

复制代码

完全可以用defaultdict()函数实现上面的计数功能：

1. colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
2. d = defaultdict(int)
3. for color in colors:
4.     d[color] += 1
5. print(d) #学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441

复制代码

更简单的方法用collections模块的Counter()函数：

1. from collections import Counter
2. colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
3. c = Counter(colors)
4. print (dict(c))

复制代码

对于备份文件，新人往往会用system模块：

1. from  os import system
2. system("xcopy e:\\sample.csv  e:\\newfile\")

复制代码

其实shutil模块更好用：

1. import shutil
2. shutil.copyfile('E:\\q.csv', 'e:\\movie\\q.csv')

复制代码

因为shutil会很详细地报告错误和异常。
大坑四：不喜欢使用异常处理

无论老手新手都应该在写代码的时候进行异常处理操作，这样可以使代码更加健壮。异常处理一般会用try...except语句
大坑五：不喜欢使用生成器

除非你的list十分复杂，并且频繁调用，否则都建议使用生成器，因为它非常节省内存，举个例子：

1. def powers_of_two(max=20000):
2.     i = 0
3.     powers = []
4.     while 2**i < max:
5.         powers.append[2**i]
6.         i += 1
7.     return powers

复制代码

对于使用次数少、占据大量内存、且容易生成的数据，可以用生成器替代列表存储：

1. from itertools import count, takewhile
2. def powers_of_two(max=20000):
3.     for index in takewhile(lambda i: 2**i < max, count(start=0)):
4.         yield 2**index

复制代码

来源:https://www.cnblogs.com/djdjdj123/p/17111862.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！