一、任务描述
上周，老板给我一个小任务：批量生成手机号码并去重。给了我一个Excel表，里面是中国移动各个地区的可用手机号码前7位（如下图），里面有十三张表，每个表里的电话号码前缀估计大概是八千个，需要这些7位号码生成每个都生成后4位组成11位手机号码，也就说每一个格子里面的手机号码都要生成一万个手机号。而且还有，本来服务器已经使用了一部分手机号码了，要在生成的号码列表里去掉已经使用过的那一批。已经使用过的这一批号码已经导出到了一批txt文本里，约4000w，每个txt有10w个号码，里面有重复的，老板估计实际大概是3000w左右。老板可以给我分配使用一个16G内存、8核CPU的Windows服务器来跑程序。
二、任务分析
要处理海量数据，所以程序的执行效率和占用内存不能太高，应该能在开发机的4G内存下也大概跑得动，即关掉所有编程IDE和服务器软件，只用Notepad++和浏览器（用来查资料）的情况下不会卡机。这次任务可能会用到的技术有：程序Excel的处理，文件的遍历和读写，大型数组的操作，多线程并发。预估任务完成周期：一周（日常工作正常进行的前提下）。
三、技术分析
PHP：很熟悉，但是执行效率和内存占用不够好，可能会卡机，要实现多线程似乎有点复杂。（有待斟酌）
Javascript：较熟悉，执行效率和内存占用不太清楚，但是弱类型通常都比较堪忧，各种回调比较干扰思维不顺手。（不考虑）
Java：略懂，学起来和写起来都比较麻烦，开发效率比较慢。（有待斟酌）
C#：没用过，较难学（比JAVA易，比脚本难）。（有待斟酌）
C/C++：略懂，数组处理、多线程这两个似乎比较难搞。（不考虑）
Python：没用过，据说很容易学，有个研究生同学用它来做物理运算等，执行效率应该不低。（试试看）
于是就打着试试看的心态，打开了菜鸟教程（Runoob）的Python教程大概看了一下，目录中有几个数组（List、元组、字典）、文件IO、File和多线程，看了一下例程果然好简单。再度娘了一下python处理Excel，果断简单快捷！于是开启了玩蛇之路。
四、合并(./4000w/hebing.py)
本文开头说到，有4000w的已用号码列表，但是里面是有重复的，而后面的处理都需要用到这些号码。而看到这400多个txt文件加起来大小约500M，所以全部读进去再进行处理也可以承受。所以先把这些文件读进去合并去重，输出成为一个txt文件。最后得到的号码有1800w多条，输出txt文件大小约209M。
#!/usr/bin/python
# -*- coding: UTF-8 -*- #把所有的文本都读出来
i = 1;
txtStrAll='';
while i<= 402: #
fileobj = open('list-data- ('+ str(i) +').txt');
txtStr = fileobj.read();
txtStrAll += txtStr+'\n';
fileobj.close();
i+=1; txtArr = txtStrAll.splitlines(); #分割成数组
print len( txtArr ); #
txtArr = list(set(txtArr)); #去重
print len( txtArr ); # #合并成字符串，for in会要很久很久
newStr = '';
newStr = '\n'.join( txtArr ); #写入txt
newFileObj = open('list-dataAll.txt', "wb");
newFileObj.write( newStr );
newFileObj.close();
hebing.py
其中对数组内的元素进行合并去重的那一句是 txtArr = list( set(txtArr) ) 。很神奇对吧，这两个是什么函数？其实这两个都是转换类型的函数。先把它转换成了 set 类型，再转换为 list 类型（列表/数组）。python的set（集合）类型是一个无序不重复的元素集，所以list转换为set之后就自动去重了，当然同时顺序也会被打乱了，不过这里的顺序不重要就不用管它啦。
最后数组转换为字符串也是直接用字符串拼接数组就转换了，不要用for循环，非常非常耗时间的。
五、Excel处理(./preNum.py)
根据网上例程直接读取Excel第一个表里面的内容出来，合并成数组转成字符串存到文本里面去。在转成字符串的时候发现报错似乎是说数据类型不对，才知道原来python与PHP、JS不同，是强类型的＝_=！于是先在Excel里把表里面的数据转换成字符串格式（excel里准确叫文本格式），转换后excel表里面的数据格左上角是有绿色的小三角形的。每个表单独处理生成一个文件，一个文件里面大概有八千个手机号码前缀。
#!/usr/bin/python
# -*- coding: UTF-8 -*- #读取Excel，把每个表的 7位 号码都读取出来，存入文件
#共有13个表（三位数前缀）， #到python官网下载http://pypi.python.org/pypi/xlrd模块安装。
#安装方法：进入下载的 xlrd的文件夹，执行命令 python setup.py install
import sys
reload(sys)
sys.setdefaultencoding('utf-8');
#解决'ascii' codec can't encode character， Python2默认是GB2312编码 import xlrd exel = xlrd.open_workbook('cellnum.xlsx'); tblIndex = 1; #第几个表
table1 = exel.sheets()[tblIndex]; #第N个表 ncols = table1.ncols; #列数
#print ncols; i=0;
dataAll = [];
while( i< ncols):
dataArr = table1.col_values( i );
# print dataArr;
for num in dataArr[:]: #每列中的数字格
if not num.isdigit() :
dataArr.remove(num); dataAll.append( dataArr );
i += 1; #dataAll 是一个表的数据List
#print dataAll; #写入txt
newStr = '';
for eCol in dataAll:
colStr = '\n'.join( eCol );
newStr += colStr+'\n'; newFileObj = open('exel-dataAll'+str(tblIndex)+'.txt', "wb");
newFileObj.write( newStr );
newFileObj.close();
preNum.py
六、生成号码并去掉已用过的
首先来想想，有十三个表，一个表里面有大概八千个号码前缀，每个前缀生成一万个号码，每个号码要与前面所说的1800万的已用手机号码进行比对去重。你会怎么做呢？？？
↓↓
↓↓
我的想法是，分成十三次来做，每次一个表，每个表中八千多个号码，使用多线程，八千多个线程，每个线程生成一万个号码并与那1800万个号码一 一比对。
其中生成和去重的核心代码如下，每生成一个号码的时间大概是0.5秒。所以估计了一下时间，10000*0.5s ≈ 83min，八千个线程大概要一个半小时左右。
#这里是重复的号码
#fileobj = open('testBugNum.txt'); #测试的
fileobj = open('list-dataAll.txt'); #实际的
bugTxtStr = fileobj.read();
fileobj.close();
bugTxtArr = bugTxtStr.splitlines(); #已用过的号码的列表 while j < 10000: #生成一万个同前缀号码
newNum = str( int(txtNum)*10000+j );
j += 1;
# print newNum; if not newNum in bugTxtArr: #如果不在已用过的号码列表里
numArr.append( '+86'+newNum );
print '+86'+newNum;
我在本机大概运行了一下，观察了几分钟，似乎线程创建得比较慢，有些已经跑到了十几个了，有的才刚创建线程。线程调度嘛，不按照顺序嘛，除了输出很乱以外，似乎也没有什么其它问题。于是就上传到服务器上去跑了，然后再过了一会就下班回家了。第二天回到公司，连上服务器看看，出乎意料啊，看到输出的信息里面，那些线程才跑到 三百多，天呐什么时候才能跑到一万啊。而且还有坑爹的是，偶尔就看到有些线程创建失败⊙o⊙
七、思考思考（./doData.py)
从前面的运行信息来看，这里使用多线程似乎并没有加快程序的运行啊，这是为什么呢？如果不能用多线程，那么生成比对的地方就要改成另外更高效的方式了，有吗？
第一问，从网上找到答案，确实说在计算密集型程序中，多线程比单线程更糟，因为一个CPU就那么几个核，不同的线程还是一样要占用CPU资源，再加上线程调度的时间和空间，真是天坑。第二问，PHP中有从一个数组去除另一个数组的函数（官方说法叫做数组的差集 array_diff() )，那么python应该也会有这样的函数，先成一万个号码的数组再进行差集 会不会比原来 每个号码对比再合并效率快呢？
实践了一下，证明确实效率高了极多极多，python中的数组差集是这个样子的 numArr = list( set(numArr) - set(bugTxtArr) ) 测了一下，大概三秒完成一批号码（一批约等于一万个号码），之前是半秒一个号码＼( ^▽^ )／。但也注意现在生成的一万个号码排序是乱的，因为中间转换成的set类型是无序的，如果需要从小到大排序，那还要再加个函数排序一下，问了老板说不用按顺序，那就直接这样了。
期间调试的时候发现，使用多线程有时会报错 Unhandled exception in thread started by sys.excepthook is missing 之类的，网上查资料说是因为主进程已经执行完毕，那么其创建的线程就会被关掉。所以我的做法就是让主进程最后为一直执行空语句，很像当年用C语言做单片机的做法呢→_→虽然最后不用多线程了，直接单线程处理，安全稳定。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import thread
from time import sleep #生成号码的函数，传入号码前缀
def generate(txtNum):
# print txtNum;
numArr = []; #用来存号码数组的
numArrStr = ''; #用来写入文件的
global doneNum;
global bugTxtArr;
global totalNum;
global tblIndex;
j = 0;
while j < 10000: #生成一万个同前缀号码
newNum = str( int(txtNum)*10000+j );
j += 1;
# print newNum;
numArr.append( newNum ); #每个对比，但是非常耗时间
# if not newNum in bugTxtArr: #如果不在已用过的号码列表里
# numArr.append( '+86'+newNum );
# #print '+86'+newNum; # 先全部合并，再数组去除（list 差集运算）
# numArr = list( set(numArr).difference(set(bugTxtArr)) );
numArr = list( set(numArr) - set(bugTxtArr) );
numArrStr = '\n'.join(numArr); #存入文件
newFileObj = open('cellNum'+str(tblIndex)+'/'+str(txtNum)+'.txt', "wb");
newFileObj.write( numArrStr );
newFileObj.close(); print '-----TASK--------'+str(txtNum)+'--OK-------------';
doneNum += 1; #完成的任务数加一
if doneNum == totalNum:
print '++++++---ALL---TASK---DONE---+++++++++++++++'; #完成所有任务 #########################################函数结束##################################### #定义要处理的表
tblIndex = 9; #把一个表合并后的数据读出来
fileobj = open('exel-dataAll'+str(tblIndex)+'.txt');
txtStr = fileobj.read();
fileobj.close();
txtArr = txtStr.splitlines(); #分割成数组
totalNum = len( txtArr );
#print txtArr; #这里是重复的号码
#fileobj = open('testBugNum.txt'); #测试的
fileobj = open('list-dataAll.txt'); #实际的
bugTxtStr = fileobj.read();
fileobj.close();
bugTxtArr = bugTxtStr.splitlines(); #已用过的号码的列表
#print bugTxtArr; print totalNum;
doneNum = 0;
num = 0;
for txtNum in txtArr:
if txtNum.isdigit() :
generate(txtNum); #生成号码 #多线程，有多少个前缀就多少个线程，每个线程生成一万个号码
#测试发现执行效率没有提高，而内存消耗大很多，查资料了解到计算密集型任务用多线程没帮助的
# try:
# thread.start_new_thread( generate, (txtNum,) )
# except:
# print "Error: "+str(txtNum)+" no Thread";
# errfileobj = open('error-log'+str(tblIndex)+'.txt', 'a');
# errfileobj.write( "Error: "+str(txtNum)+" no Thread\n" );
# errfileobj.close(); # num += 1;
# if num > 10:
# break; #sleep(1);
#print 'sleep end';
#while 1==1 : #主程序一直执行，以防线程提早结束
# pass;
doData.py
八、合并整理(./hbData.py)
经过了大概六个小时的号码生成，最后就是把一个Excel表生成的八千多个文件整理，每十个文件合成一个，每个文件约十万个号码，每个号码前面加上 “+86” 。就遍历一下目录，没什么技术点就不详说了。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os def hebing( filesArr ):
global tblIndex;
i = 0;
newStr = '';
filesArrLen = len(filesArr);
#print filesArr;
for file in filesArr:
txtStrAll = '';
fileobj = open('cellNum'+str(tblIndex)+'/'+filesArr[i]);
txtStr = fileobj.read();
fileobj.close();
txtStrAll += txtStr+'\n'; txtArr = txtStrAll.splitlines(); #分割成数组 #全部在开头加上+86
arrLen = len(txtArr);
#print arrLen;
for j in range(0, arrLen):
txtArr[j] = "+86"+txtArr[j]; #转成字符串
newStr += '\n'.join(txtArr); i += 1; #每10个文件写入txt，注意最后的不足十个的时候
if not i%10 :
#print i;
newFileObj = open('resList'+str(tblIndex)+'/'+str(i)+'.txt', "wb");
newFileObj.write( newStr );
newFileObj.close();
newStr = '';
elif i==filesArrLen :
#print i;
newFileObj = open('resList'+str(tblIndex)+'/'+str(i)+'.txt', "wb");
newFileObj.write( newStr );
newFileObj.close();
newStr = ''; #把所有的文本都读出来
tblIndex = 1;
rootDir = os.getcwd()+"\cellNum"+str(tblIndex);
#print rootDir;
for parent,dirs,files in os.walk(rootDir):
# print files; #得到一个文件名List，按文件名排序的
# hebing( files[0:15] ); #测试
hebing( files ); """
i = 1;
txtStrAll='';
while i<= 402: #402
fileobj = open('list-data- ('+ str(i) +').txt');
txtStr = fileobj.read();
txtStrAll += txtStr+'\n';
fileobj.close();
i+=1; txtArr = txtStrAll.splitlines(); #分割成数组
print len( txtArr ); #39905386
txtArr = list(set(txtArr)); #去重
print len( txtArr ); #18316857 #合并成字符串，for in会要很久很久
newStr = '';
newStr = '\n'.join( txtArr ); #写入txt
newFileObj = open('list-dataAll.txt', "wb");
newFileObj.write( newStr );
newFileObj.close();
"""
hbData.py
后话，总共只有十三个表，这些程序稍微改一下，执行十三次就行了。值得注意的是，我这里的程序几乎每个都有一个全局变量 tblIndex， 是以防一文件里面一个个修改目录名和文件名，疏忽有可能导致的数据覆盖。
总结
- 使用脚本语言有一个很重要的要点：要尽量用语言提供的函数，不要自己实现算法，尤其是循环的那种，执行速度不在一个数量级。
- 处理大批量的数据，要拆分步骤，生成中间文件。大量数据复杂操作要小批量小批量地慢慢调试，结果无误才逐步切换成真实数据。
- 多线程在运算密集型的场景中是没有用武之处的，就算CPU是多核也没什么用，反而会造成顺序随机不易观察，线程不稳定容易出错，线程间切换内存消耗加大等弊端。
- 据说GPU可以用来挖矿、暴力破解等，对本场景这种高并发、简单逻辑的运算应该也非常适用，以后可能要用得上GPU编程（求推荐教程）。