Python加快了从超大字符串检索数据的速度

往下看：

我有一个列表，我转换成一个非常长的字符串，因为我试图编辑它，因为你可以收集它被称为tempString。到目前为止，它还可以工作，只是需要很长时间才能运行，可能是因为它是几个不同的正则表达式子类。详情如下:

tempString = ','.join(str(n) for n in coords)
tempString = re.sub(',{2,6}', '_', tempString)
tempString = re.sub("[^0-9\-\.\_]", ",", tempString)
tempString = re.sub(',+', ',', tempString)
clean1 = re.findall(('[-+]?[0-9]*\.?[0-9]+,[-+]?[0-9]*\.?[0-9]+,'
                 '[-+]?[0-9]*\.?[0-9]+'), tempString)
tempString = '_'.join(str(n) for n in clean1)
tempString = re.sub(',', ' ', tempString)

基本上，它是一个长字符串，包含逗号和大约1-5百万组4个浮点/整数（两种可能的混合）：

每个集合中我不需要/不想要的第四个数字，我基本上只是尝试将字符串拆分为一个列表，每个列表中有3个浮点数，每个浮点数之间用空格分隔

上面的代码可以完美地工作，但正如您所想象的，在大型字符串上非常耗时

我在这里做了大量的研究来寻找解决方案，但它们似乎都是针对单词的，即用一个单词替换另一个单词

---

编辑： 好的，这就是我目前使用的解决方案：

def getValues(s):
    output = []
    while s:
        # get the three values you want, discard the 3 commas, and the 
        # remainder of the string
        v1, v2, v3, _, _, _, s = s.split(',', 6)
        output.append("%s %s %s" % (v1.strip(), v2.strip(), v3.strip()))         
    return output
coords = getValues(tempString)

有人有什么建议可以让这更进一步吗？在运行了一些测试之后，仍然需要比我期望的更长的时间

我一直在浏览numPy，但我真的完全不知道如何使用它来处理上面的内容，我知道在完成上面的工作并清理这些值之后，我可以更有效地使用numPy，但不确定numPy如何应用于上面的内容

---

上面提到的清理50k套需要大约20分钟，我无法想象在我100万套的整条线上需要多长时间。我很惊讶，最初导出数据的程序只花了大约30秒的时间就完成了100万组数据

减少内存消耗而不必更改正则表达式中的任何内容的一种方法是使用

re.finditer（）

方法，而不是

re.findall（）

。这将逐个遍历这些值，而不是将整个字符串读入单个列表对象

根据您的样本数据：

>>> s = "-5.65500020981,6.88999986649,-0.454999923706,1,,,-5.65500020981,6.95499992371,-0.454999923706,1,,,"
>>> def getValues(s):
...     output = []
...     while s:
...         # get the three values you want, discard the 3 commas, and the 
...         # remainder of the string
...         v1, v2, v3, _, _, _, s = s.split(',', 6)
...         output.append("%s %s %s" % (v1, v2, v3))
...         
...     return output
>>> getValues(s)
['-5.65500020981 6.88999986649 -0.454999923706', '-5.65500020981 6.95499992371 -0.454999923706']

…一旦将这些解析值作为字符串放入列表中，您就可以执行任何其他需要执行的操作

或者，如果愿意，可以使用生成器，这样就不需要一次生成整个返回字符串：

>>> def getValuesGen(s):
...     while s:
...         v1, v2, v3, _, _, _, s = s.split(',', 6)
...         yield "%s %s %s" % (v1, v2, v3)
>>> for v in getValuesGen(s):
...     print v
...     
... 
-5.65500020981 6.88999986649 -0.454999923706
-5.65500020981 6.95499992371 -0.454999923706

您可能还想尝试一种方法，在

，，

逗号集上预先拆分长列表，而不是不断构建和处理一组较短的字符串，如：

>>> def getValues(s):
...     # split your long string into a list of chunked strings
...     strList = s.split(",,,")
...     for chunk in strList:
...         if chunk:
...         # ...then just parse apart each individual set of data values
...             vals = chunk.split(',')
...             yield "%s %s %s" % (vals[0], vals[1], vals[2])
>>> for v in getValues(s10):
...     print v
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454

---

在某些情况下，当您处理像这样的大型数据集并遇到速度问题时，将内容下推到使用C语言进行繁重工作的模块（如NumPy）中是有意义的。

将其拆分为一个列表（

tempString.Split（“，”）

），然后对其进行操作。当你唯一的工具是正则表达式时，每个问题都开始类似于一个字符串。所有的数字都是相同的十进制精度吗？它最初是一个列表，我将它转换为一个字符串进行更改，然后在更改完成后返回到一个列表，我不知道如何直接在计算机上获得所需的更改list@Asad不，不幸的是，它是完全随机的/无论用户使用什么/程序，它也可能是int，我将进行编辑以澄清，如果您需要有效地操纵2000万个浮点，可以使用numpy数组。这似乎工作得很好，感谢您的帮助，我确实有一个问题，每隔一段时间，大约每10组就有一个问题：'-2.59999090463\n\t\t\t\t\t\t\t\t7.2799973297 0.78000150204'，'-2.5999990463 7.344999990019-0.51999921322'，关于从列表项中删除\n和\t的任何建议，似乎只发生在上述值的开头，我可以在def getValues中包含一些东西来修复它吗？再次感谢您的帮助尝试在字符串上使用

strip（）

方法清理垃圾，如

%s%s“%（v1.strip（），v2.strip（），v3.strip（））

工作正常，非常感谢您的帮助，速度比以前快了很多。我将尝试与NumPy一起研究J.F.塞巴斯蒂安的建议，看看这是否能进一步提高我的效率，谢谢！很抱歉，打扰您了，但是我想知道您是否有更多关于加速的建议或我应该研究的特定模块，尽管我更喜欢保持它的外部模块免费，也就是说，除非我也有，否则不必下载任何东西，谢谢

>>> def getValues(s):
...     # split your long string into a list of chunked strings
...     strList = s.split(",,,")
...     for chunk in strList:
...         if chunk:
...         # ...then just parse apart each individual set of data values
...             vals = chunk.split(',')
...             yield "%s %s %s" % (vals[0], vals[1], vals[2])
>>> for v in getValues(s10):
...     print v
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454
-5.1  6.8  -0.454