如何写出高质量的Python代码--做好优化--改进算法点滴做起

小伙伴你的程序还是停留在糊墙吗？优化代码可以显示程序员的素质欧！

普及一下基础了欧：

一层for简写：y = [1,2,3,4,5,6]，[(i*2) for i in y ]       会输出  [2, 4, 6, 8, 10, 12] ，标准形式为： [ 对i的操作 for i in 列表 ]

两层for循环：[对i的操作 for 单个元素 in 列表 for i in 单个元素]，

例子：

1. y_list = ['assss','dvv'] 
2. [print(i) for y in y_list for i in y]

输出：a s s s s d v v

相当于：

y_list = ['assss','dvv']
for y in y_list:
    for i in y:
        print(i)

if简写：[True的逻辑 if 条件 else False的逻辑]
例子：

1. y = 0
2.  x = y+3 if y > 3 else y-1

for 与 if 的结合怎么简写：[判断为True的i的操作 for i in 列表 if i的判断 ]

1. x = [1,2,3,4,5,6,7]
2. [print(i) for i in x if i > 3 ]

Python 代码优化常见技巧

　　代码优化能够让程序运行更快，它是在不改变程序运行结果的情况下使得程序的运行效率更高，根据 80/20 原则，实现程序的重构、优化、扩展以及文档相关的事情通常需要消耗 80% 的工作量。优化通常包含两方面的内容：减小代码的体积，提高代码的运行效率。

改进算法，选择合适的数据结构

　　一个良好的算法能够对性能起到关键作用，因此性能改进的首要点是对算法的改进。在算法的时间复杂度排序上依次是：

O(1) -> O(lg n) -> O(n lg n) -> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!)

定位程序性能瓶颈

　　对代码优化的前提是需要了解性能瓶颈在什么地方，程序运行的主要时间是消耗在哪里，对于比较复杂的代码可以借助一些工具来定位，python 内置了丰富的性能分析工具，如 profile,cProfile 与 hotshot 等。其中 Profiler 是 python 自带的一组程序，能够描述程序运行时候的性能，并提供各种统计帮助用户定位程序的性能瓶颈。Python 标准模块提供三种 profilers:cProfile,profile 以及 hotshot。

使用 profile 进行性能分析

import profile 
def profileTest(): 
   Total =1; 
   for i in range(10): 
       Total=Total*(i+1) 
       print(Total) 
   return Total 
if __name__ == "__main__": 
   profile.run("profileTest()") 

分析功能函数：这个可以直接使用的，自己查就行了

• ncalls：表示函数调用的次数；
• tottime：表示指定函数的总的运行时间，除掉函数中调用子函数的运行时间；
• percall：（第一个 percall）等于 tottime/ncalls；
• cumtime：表示该函数及其所有子函数的调用运行的时间，即函数开始调用到返回的时间；
• percall：（第二个 percall）即函数运行一次的平均时间，等于 cumtime/ncalls；
• filename:lineno(function)：每个函数调用的具体信息；

• 如果需要将输出以日志的形式保存，只需要在调用的时候加入另外一个参数。如 profile.run("profileTest()"，"testprof")。

  对于 profile 的剖析数据，如果以二进制文件的时候保存结果的时候，可以通过 pstats 模块进行文本报表分析，它支持多种形式的报表输出，是文本界面下一个较为实用的工具。使用非常简单：

  import pstats
  p = pstats.Stats('testprof')
  p.sort_stats("name").print_stats()  

  　　其中 sort_stats() 方法能够对剖分数据进行排序， 可以接受多个排序字段，如 sort_stats('name'， 'file') 将首先按照函数名称进行排序，然后再按照文件名进行排序。常见的排序字段有 calls( 被调用的次数 )，time（函数内部运行时间），cumulative（运行的总时间）等。此外 pstats 也提供了命令行交互工具，执行 python – m pstats 后可以通过 help 了解更多使用方式。

  　　对于大型应用程序，如果能够将性能分析的结果以图形的方式呈现，将会非常实用和直观，常见的可视化工具有 Gprof2Dot，visualpytune，KCacheGrind 等，读者可以自行查阅相关官网，本文不做详细讨论。

时间复杂度

算法的时间复杂度对程序的执行效率影响最大，在 Python 中可以通过选择合适的数据结构来优化时间复杂度，如 list 和 set 查找某一个元素的时间复杂度分别是 O(n)和 O(1)。不同的场景有不同的优化方式，总得来说，一般有分治，分支界限，贪心，动态规划等思想。

循环优化

每种编程语言都会强调需要优化循环。对循环的优化所遵循的原则是尽量减少循环过程中的计算量，有多重循环的尽量将内层的计算提到上一层。当使用 Python 的时候，你可以依靠大量的技巧使得循环运行得更快。然而，开发者经常漏掉的一个方法是：

避免在一个循环中使用点操作。每一次你调用方法 str.upper，Python 都会求该方法的值。然而， 如果你用一个变量代替求得的值，值就变成了已知的，Python 就可以更快地执行任务。优化循环的关键，是要减少 Python 在循环内部执行的工作量，因为 Python 原生的解释器在那种情况下，真的会减缓执行的速度。（注意：优化循环的方法有很多，这只是其中的一个。例如，许多程序员都会说，列表推导是在循环中提高执行速度的最好方式。这里的关键是，优化循环是程序取得更高的执行速度的更好方式之一。）

为进行循环优化前

from time import time 
t = time() 
lista = [,,,,,,,,,] 
listb =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01] 
for i in range (): 
     for a in range(len(lista)): 
         for b in range(len(listb)): 
             x=lista[a]+listb[b] 
print("total run time:")
print(time()-t)
　　#现在进行如下优化，将长度计算提到循环外，range 用 xrange 代替，同时将第三层的计算 lista[a] 提到循环的第二层。

　　# 循环优化后

from time import time 
t = time() 
lista = [,,,,,,,,,] 
listb =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01] 
len1=len(lista) 
len2=len(listb) 
for i in xrange (): 
     for a in xrange(len1): 
         temp=lista[a] 
         for b in xrange(len2): 
             x=temp+listb[b] 
print("total run time:")
print(time()-t)
　　#上述优化后的程序其运行时间缩短为 102.171999931。在清单 4 中 lista[a] 被计算的次数为 1000000*10*10，而在优化后的代码中被计算的次数为 1000000*10，计算次数大幅度缩短，因此性能有所提升。

　　#充分利用 Lazy if-evaluation 的特性

　　#python 中条件表达式是 lazy evaluation 的，也就是说如果存在条件表达式 if x and y，在 x 为 false 的情况下 y 表达式的值将不再计算。因此可以利用该特性在一定程度上提高程序效率。

　　#利用 Lazy if-evaluation 的特性

from time import time 
t = time() 
abbreviations = ['cf.', 'e.g.', 'ex.', 'etc.', 'fig.', 'i.e.', 'Mr.', 'vs.'] 
for i in range (): 
     for w in ('Mr.', 'Hat', 'is', 'chasing', 'the', 'black', 'cat', '.'): 
         if w in abbreviations: 
         #if w[-1] == '.' and w in abbreviations: 
pass 
print("total run time:")
print(time()-t)

　　#在未进行优化之前程序的运行时间大概为 8.84，如果使用注释行代替第一个 if，运行的时间大概为 6.17。

并行编程

因为 GIL 的存在，Python 很难充分利用多核 CPU 的优势。但是，可以通过内置的模块
multiprocessing 实现下面几种并行模式：
多进程：对于 CPU 密集型的程序，可以使用 multiprocessing 的 Process，Pool 等封装好的类， 通过多进程的方式实现并行计算。但是因为进程中的通信成本比较大，对于进程之间需要大量数据交互的程序效率未必有大的提高。
多线程：对于 IO 密集型的程序，multiprocessing.dummy 模块使用 multiprocessing 的接口封装 threading，使得多线程编程也变得非常轻松(比如可以使用 Pool 的 map 接口，简洁高效)。
分布式：multiprocessing 中的 Managers 类提供了可以在不同进程之共享数据的方式，可以在此基础上开发出分布式的程序。
不同的业务场景可以选择其中的一种或几种的组合实现程序性能的优化。

使用性能分析工具

set 的用法

set 的 union，intersection，difference 操作要比 list 的迭代要快。因此如果涉及到求 list 交集，并集或者差的问题可以转换为 set 来操作。

字符串的优化

　　python 中的字符串对象是不可改变的，因此对任何字符串的操作如拼接，修改等都将产生一个新的字符串对象，而不是基于原字符串，因此这种持续的 copy 会在一定程度上影响 python 的性能。对字符串的优化也是改善性能的一个重要的方面，特别是在处理文本较多的情况下。字符串的优化主要集中在以下几个方面：

• 在字符串连接的使用尽量使用 join() 而不是 +：在代码清单 7 中使用 + 进行字符串连接大概需要 0.125 s，而使用 join 缩短为 0.016s。因此在字符的操作上 join 比 + 要快，因此要尽量使用 join 而不是 +。

• 当对字符串可以使用正则表达式或者内置函数来处理的时候，选择内置函数。如 str.isalpha()，str.isdigit()，str.startswith(('x'， 'yz'))，str.endswith(('x'， 'yz'))
• 对字符进行格式化比直接串联读取要快。4、
• 使用列表解析（list comprehension）和生成器表达式（generator expression）。列表解析要比在循环中重新构建一个新的 list 更为高效，因此我们可以利用这一特性来提高运行的效率。
• 如果需要交换两个变量的值使用 a,b=b,a 而不是借助中间变量 t=a;a=b;b=t；
• 使用局部变量，避免"global" 关键字。python 访问局部变量会比全局变量要快得多，因 此可以利用这一特性提升性能。

    6.在耗时较多的循环中，可以把函数的调用改为内联的方式；

7.使用级联比较 "x < y < z" 而不是 "x < y and y < z"；

8.while 1 要比 while True 更快（当然后者的可读性更好）；

9.build in 函数通常较快，add(a,b) 要优于 a+b。

1.Python实现全排列

方案一：

1.  
   a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2.  
   result = list(itertools.permutations(a, 9))

方案二：
上面是使用python的内建函数itertools.permutations对于只有9个元素的全排列速度上是惊人的。
如果是我们自己来写全排列逻辑，可以是下面这样的：

def full_permutation(l):
    if (len(l) <= 1):
        return [l]

    r = []
    for i in range(len(l)):
        s = l[:i] + l[i + 1:]  # 将l的前三项以及l的第i+1后的字串赋给s
        p = full_permutation(s)
        for x in p:
            r.append(l[i: i + 1] + x)

    return r

所有在项目中还是建议使用Python内建的全排列函数，其中的第二个参数可以是1-9之间的任何一个整数，非常方便。2.

2、遍历文件夹下所有子文件夹和文件
在Python中可以很方便地对文件目录进行循环遍历，检查文件及目录，代码如下：
  import os

import os.path

def cycle_visiting(root_dir=None):
    for parent, folder_names, file_names in os.walk(root_dir):
        for folder_name in folder_names:
            print('folder: ' + folder_name)
        for file_name in file_names:
            print('file: ' + os.path.join(parent, file_name))

3.针对字符串的进制转化

  如果你有其他语言的编程功底，可能你已对进制转化十分熟悉。不过我这里要说的进制转化可不是简单从十进制转化为二进制或是转成十六进制。下面你可以试着来解决下面几个问题：
  a.将a = 'ff'的十六进制数转成十进制的255
  b.将a = 14的十进制数转成十六进制的0e
解决方法：
  a.这里需要用一个参数指明原来的进制数
decstr = int(a, 16)
  b.这里需要用一个切片操作用来去掉前缀'0x'
decstr = hex(a)[2:]
if len(decstr) % 2 == 1:
    decstr = '0' + decstr

4.IP的点分型和整形数字之间的转化

  首先需要import两个模块：socket和struct
  1.将ip1 = '172.123.156.241'转化为ip2 = 2893782257L
    ip2 = socket.ntohl(struct.unpack("I",socket.inet_aton(ip1))[0])
  2.将ip2 = 2893782257L转化为ip1 = '172.123.156.241'
    ip1 = socket.inet_ntoa(struct.pack('I',socket.htonl(ip2)))

5.Python获得Linux控制台中的输出信息

  可以通过两种方式来解决这个问题，分别如下：
  方法一：

1.  
   import subprocess
2.  
   import os
3.  
   output = os.popen('cat /proc/cpuinfo | grep model')
4.  
   print output.read()

  方法二：

1.  
   status, model = commands.getstatusoutput(shell)
2.  

6.使用enumerate()函数获取序列迭代的索引和值

有时我们在对序列进行迭代的时候，不单单是只要知道序列中的值，还想要知道这个值在序列的什么位置。

如果要使用代码实现，的确不难。不过会显得多余，因为Python已经为我们做了这些工作。如下：

def test_enumerate():
    array = [, , , , , ]
    for index, data in enumerate(array):
        print("%d: %d" % (index, data))
t = test_enumerate()

7.i+=1与++i有区别

我们知道Python中是不支持自增操作的。所以，你是不是就会以为这里的++i会抛出一个语法错误呢？

很可惜，这里并不会抛出语法错误。对于i++的确是有这样的问题，不过对于++i则不会。例如在PyCharm编辑器中，我们可以看到如下现象：

我们可以看到PyCharm对a++抛出了一个错误提示，对于++a则是一个警告。

原因是在Python里，++a会被看成是+(+a)，也就是说，“+”被理解成了一个正符号。所以，++a的结果还是a。同理，--a的结果也是a.

2.遍历文件夹下所有子文件夹和文件

在Python中可以很方便地对文件目录进行循环遍历，检查文件及目录，代码如下：

1.  
   import os
2.  
   import os.path
3.  
    
4.  
   def cycle_visiting(root_dir=None):
5.  
   for parent, folder_names, file_names in os.walk(root_dir):
6.  
   for folder_name in folder_names:
7.  
   print 'folder: ' + folder_name
8.  
   for file_name in file_names:

9. 定位程序性能瓶颈

   　　对代码优化的前提是需要了解性能瓶颈在什么地方，程序运行的主要时间是消耗在哪里，对于比较复杂的代码可以借助一些工具来定位，python 内置了丰富的性能分析工具，如 profile,cProfile 与 hotshot 等。其中 Profiler 是 python 自带的一组程序，能够描述程序运行时候的性能，并提供各种统计帮助用户定位程序的性能瓶颈。Python 标准模块提供三种 profilers:cProfile,profile 以及 hotshot

   定位程序性能瓶颈

   　　对代码优化的前提是需要了解性能瓶颈在什么地方，程序运行的主要时间是消耗在哪里，对于比较复杂的代码可以借助一些工具来定位，python 内置了丰富的性能分析工具，如 profile,cProfile 与 hotshot 等。其中 Profiler 是 python 自带的一组程序，能够描述程序运行时候的性能，并提供各种统计帮助用户定位程序的性能瓶颈。Python 标准模块提供三种 profilers:cProfile,profile 以及 hotshot