python语言-pep8使用技巧

发表于 | 分类于 | 评论数： | 阅读次数：
本文字数： 5.3k | 阅读时长 ≈ 5 分钟

摘要

本文部分内容来源于网络，个人收集整理，请勿传播

Python由于语言的简洁性，让我们以人类思考的方式来写代码，新手更容易上手，老鸟更爱不释手。

要写出 Pythonic（优雅的、地道的、整洁的）代码，还要平时多观察那些大牛代码，Github 上有很多非常优秀的源代码值得阅读，比如：requests、flask、tornado，这里小明收集了一些常见的 Pythonic 写法，帮助你养成写优秀代码的习惯。

python技巧

序列解包

1
2
3
4
5
a, *rest = [1, 2, 3]
# a = 1, rest = [2, 3]

a, *middle, c = [1, 2, 3, 4]
# a = 1, middle = [2, 3], c = 4

遍历列表以及索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
##不推荐
items = 'zero one two three'.split()
# method 1
i = 0
for item in items:
    print i, item
    i += 1
# method 2
for i in range(len(items)):
    print i, items[i]

##推荐
items = 'zero one two three'.split()
for i, item in enumerate(items):
    print i, item

字典get和setdefault方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
##不推荐
navs = {}
for (portfolio, equity, position) in data:
    if portfolio not in navs:
            navs[portfolio] = 0
    navs[portfolio] += position * prices[equity]
##推荐
navs = {}
for (portfolio, equity, position) in data:
    # 使用 get 方法
    navs[portfolio] = navs.get(portfolio, 0) + position * prices[equity]
    # 或者使用 setdefault 方法
    navs.setdefault(portfolio, 0)
    navs[portfolio] += position * prices[equity]

遍历列表以及索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
##不推荐
items = 'zero one two three'.split()
# method 1
i = 0
for item in items:
    print i, item
    i += 1
# method 2
for i in range(len(items)):
    print i, items[i]

##推荐
items = 'zero one two three'.split()
for i, item in enumerate(items):
    print i, item

列表推导-嵌套

1
2
3
4
5
6
7
8
9
10
11
##不推荐
for sub_list in nested_list:
    if list_condition(sub_list):
        for item in sub_list:
            if item_condition(item):
                # do something...  
##推荐
gen = (item for sl in nested_list if list_condition(sl) 
            for item in sl if item_condition(item))
for item in gen:
    # do something...

循环嵌套

1
2
3
4
5
6
7
8
9
10
##不推荐
for x in x_list:
    for y in y_list:
        for z in z_list:
            # do something for x & y  

##推荐
from itertools import product
for x, y, z in product(x_list, y_list, z_list):
    # do something for x, y, z

中间结果尽量使用imap/ifilter代替map/filte

1
2
3
4
5
6
7
##不推荐
reduce(rf, filter(ff, map(mf, a_list)))

##推荐
from itertools import ifilter, imap
reduce(rf, ifilter(ff, imap(mf, a_list)))
*lazy evaluation 会带来更高的内存使用效率，特别是当处理大数据操作的时候。

使用any/all函数

1
2
3
4
5
6
7
8
9
10
11
12
##不推荐
found = False
for item in a_list:
    if condition(item):
        found = True
        break
if found:
    # do something if found...  

##推荐
if any(condition(item) for item in a_list):
    # do something if found...

属性(property)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
##不推荐
class Clock(object):
    def __init__(self):
        self.__hour = 1
    def setHour(self, hour):
        if 25 > hour > 0: self.__hour = hour
        else: raise BadHourException
    def getHour(self):
        return self.__hour

##推荐
class Clock(object):
    def __init__(self):
        self.__hour = 1
    def __setHour(self, hour):
        if 25 > hour > 0: self.__hour = hour
        else: raise BadHourException
    def __getHour(self):
        return self.__hour
    hour = property(__getHour, __setHour)

使用 with 忽视异常(仅限Python 3)

1
2
3
4
5
6
7
8
9
10
11
##不推荐
try:
    os.remove("somefile.txt")
except OSError:
    pass

##推荐
from contextlib import ignored  # Python 3 only

with ignored(OSError):
    os.remove("somefile.txt")

使用 with 处理加锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
##不推荐
import threading
lock = threading.Lock()

lock.acquire()
try:
    # 互斥操作...
finally:
    lock.release()

##推荐
import threading
lock = threading.Lock()

with lock:
    # 互斥操作...

使用占位符

1
2
filename = 'foobar.txt'
basename, _, ext = filename.rpartition('.')

链式比较

1
2
3
4
5
6
7
8
9
# 不推荐
if age > 18 and age < 60:
    print("young man")
# 推荐
if 18 < age < 60:
    print("young man")

>>> False == False == True 
False

<.>和<.?>有什么区别

<.>这种匹配称作贪心匹配<.?>称作非贪心匹配

Python里面search()和match()的区别

match（）函数只检测RE是不是在string的开始位置匹配， search()会扫描整个string查找匹配, 也就是说match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none

如何用Python来进行查询和替换一个文本字符串？

可以使用sub()方法来进行查询和替换，sub方法的格式为：sub(replacement, string[, count=0])

  • replacement是被替换成的文本
  • string是需要被替换的文本
  • count是一个可选参数，指最大被替换的数量
1
2
3
4
import re
p = re.compile(’(blue|white|red)’)
print(p.sub(’colour’,'blue socks and red shoes’))
print(p.sub(’colour’,'blue socks and red shoes’, count=1))

subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量

1
2
3
4
import re
p = re.compile(’(blue|white|red)’)
print(p.subn(’colour’,'blue socks and red shoes’))
print(p.subn(’colour’,'blue socks and red shoes’, count=1))

有两个序列a,b，大小都为n,序列元素的值任意整形数

无序；要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
将两序列合并为一个序列，并排序，为序列Source

拿出最大元素Big，次大的元素Small

在余下的序列S[:-2]进行平分，得到序列max，min

将Small加到max序列，将Big加大min序列，重新计算新序列和，和大的为max，小的为min。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def mean( sorted_list ):
	if not sorted_list:
		return (([],[]))
	big = sorted_list[-1]
	small = sorted_list[-2]
	big_list, small_list = mean(sorted_list[:-2])
	big_list.append(small)
	small_list.append(big)
	big_list_sum = sum(big_list)
	small_list_sum = sum(small_list)
	if big_list_sum > small_list_sum:
		return ( (big_list, small_list))
	else:
		return (( small_list, big_list))
	tests = [   [1,2,3,4,5,6,700,800],
		[10001,10000,100,90,50,1],
		range(1, 11),
		[12312, 12311, 232, 210, 30, 29, 3, 2, 1, 1]
	]
	for l in tests:
		l.sort()
		print
		print “Source List:    ”, l
l1,l2 = mean(l)
print “Result List:    ”, l1, l2
print “Distance:    ”, abs(sum(l1)-sum(l2))
print ‘-*’*40