python读取fasta序列,
作为一种编程语言，Python在可读性和可维护性方面有其独特的优势。越来越多的人使用Python进行数据分析和处理。Pandas旨在解决数据分析的任务。它包含了大量可以轻松处理数据的函数和方法，是Python成为强大高效的数据分析环境的重要因素之一。
但是熊猫是内存的类库，处理小数据(放入内存)没有问题，对于大数据(放入内存)不是很方便。在日常工作中，我们经常会遇到这样的大文件(从数据库或者网站下载的数据)，但是熊猫却无能为力，只能自己想办法。我们将讨论这个问题。
本文所指的大数据并不是需要TB或PB分布式处理的大数据，而是普通PC无法加载到内存中，但GB文件数据可以存在于硬盘中。
因为这些文件无法一次性读入内存，所以在处理数据时，通常需要逐行或逐块读取。虽然Python和熊猫在读取文件时都支持这种方法，但是因为没有光标系统，所以有些函数和方法必须单独使用，或者函数和方法本身必须自己写代码。这里介绍一些常见问题，并写代码示例供读者参考。
一.聚合
在简单集约中，只需要遍历一次数据，根据集约目标计算一次集约列。例如，sum包括数据遍历期间读取的数据；在计数和遍历数据的情况下，只需记录遍历次数即可；意思是扫描时，同时记录累计次数和扫描次数，最后除以。以这里的问题为例来介绍一下。
这些文件包括：数据段如下所示。
现在你需要计算总销售额。(金额栏))。
(1)逐行阅读
总计=0
withopen(Orders.txt，)r))作为f:
line=f.readline())
虽然正确：
line=f.readline())
如果不行：
黑色
total=float(line.split ) (t)))
是打印(总计)
打开文件
标题行
逐行阅读
在你理解内容之前结束。
累积加法
(二)熊猫阻断引线
熊猫可以用来阅读积木。工作逻辑的结构如下图所示。
进口熊猫作为pd
chunk _ data=PD . read _ CSV(orders . txt)、sep=\t 、chunksize=100000))
总计=0
对于chunk_data中的块：
total=chunk[金额]。总和(
是打印(总计)
一步一步读文件，每一行十万行。
每个细分市场的累计销售额
熊猫擅长计算更长的线段。理论上，chunksize越大，计算速度越快，但请注意内存限制。不建议使用熊猫逐行读取文件，因为将“chunksize”设置为1会导致逐行读取，非常慢。
二。过滤
过滤器流程图：
和过滤聚合一样，把一个大文件分成N段，过滤每一段，最后合并每一段的结果。
以上述数据为例，继续筛选纽约州的销售信息。
(A)小结果集
进口熊猫作为pd
chunk _ data=PD . read _ CSV(orders . txt)、sep=\t 、chunksize=100000))
chunk_list=[]
对于chunk_data中的块：
chunk _ list . append(chunk[chunk . state== new York )
RES=PD.concat(chunk_list))。
是，打印(分辨率)
定义一个空列表来保存结果。
分段滤波
结果合并
(B)大结果集
进口熊猫作为pd
chunk _ data=PD . read _ CSV(orders . txt)、sep=\t 、chunksize=100000))
n=0
对于chunk_data中的块：
need _ data=chunk[chunk . state== new York ]
如果n==0:
need _ data . to _ CSV(orders _ filter . txt)(index=None))))))))))))))))))).
n=1
否则：
n
eed _ data . to _ CSV( orders _ filter . txt ，index=None，mode=a ，header=None)
第一段，写文件，保留头，但不保留索引。
其他数据段、标题和索引不会通过额外写入来保留。
大文件聚合和过滤操作的逻辑相对简单，但是因为Python不直接提供游标数据类型，代码要写很多行。
第三，排序
顺序流程图：
排序就麻烦多了，如上图所示：
1、分段读取数据；
2.对每个段落进行排序；
3.将每段的排序结果写出到一个临时文件中；
4.维护一个k元素的列表(k等于段数)，每个临时文件放一行数据到列表中；
5.对列表中记录的已排序字段进行排序(同第二步，升序为升序，降序为降序)；
6.将列表的最小或最大记录写出到结果文件中(最小按升序，最大按降序)；
7.从写入记录的临时文件中读取另一行，并将其放入列表中；
8.重复步骤6.7，直到所有记录都写入结果文件。
以上述数据为例，用Python写一个完整的外存排序算法，将文件中的数据按订单金额升序排序。
进口熊猫作为pd
导入操作系统
导入时间
导入技能
导入uuid
导入追溯
定义解析类型：
if s.isdigit():
返回整数
尝试：
res=浮点数
返回资源
除了：
返回s
定义位置_由(由，主管，部门):
by_num=0
对于head.split中的列(sep):
if col.strip()==by:
破裂
否则：
by_num=1
退货数量
def merge_sort(directory，ofile，by，ascending=True，sep=，):
使用open(ofile， w )作为outfile:
file_list=os.listdir(目录)
file _ chunk=[open(directory / file， r )for file _ list]
k_row=[file_chunk[i]。readline()for I in range(len(file _ chunk))]
by=pos_by(by，k_row[0]，sep)
outfile.write(k_row[0])
k_row=[file_chunk[i]。readline()for I in range(len(file _ chunk))]
k_by=[parse_type(k_row[i])。split(sep)[by]。strip())for I in range(len(file _ chunk))]
用open(ofile， a )作为outfile:
虽然正确：
对于范围内的I(len(k _ by)):
如果i=len(k_by):
破裂
如果升序，sorted_k_by=sorted(k_by ),否则sorted(k_by，reverse=True)
if k_by[i]==sorted_k_by[0]:
outfile.write(k_row[i])
k_row[i]=file_chunk[i]。读取线()
如果不是k_row[i]:
file_chunk[i]。关闭()
del(文件块[i])
del(k_row[i])
del(k_by[i])
否则：
k_by[i]=parse_type(k_row[i])。split(sep)[by]。strip())
如果len(k_by)==0:
破裂
def external_sort(file_path，by，of file，tmp_dir，ascending=True，chunksize=50000，sep=，，usecols=None，index_col=None):
os.makedirs(tmp_dir，exist_ok=True)
尝试：
data _ chunk=PD . read _ CSV(file _ path，sep=sep，usecols=usecols，index_col=index_col，chunksize=chunksize)
对于data_chunk中的块：
chunk=chunk.sort_values(by，ascending=ascending)
chunk . to _ CSV(tmp _ dir / chunk str(int(time . time()* 10 * * 7))str(uuid . uuid 4())。csv ，索引=无，sep=sep)
merge_sort(tmp_dir，ofile=ofile，by=by，ascending=ascending，sep=sep)
例外情况除外：
print(traceback.format_exc())
最后：
shutil.rmtree(tmp_dir，ignore_errors=True)
if __name__==__main__ :
infile= D:/python _ question _ data/orders . txt
ofile= D:/python _ question _ data/extra _ sort _ RES _ py . txt
tmp= D:/python _ question _ data/tmp
external_sort(infile， amount ，ofile，tmp，ascending=True，chunksize=1000000，sep=\t )
功能
分析字符串的数据类型。
功能
计算标题中要排序的列名的位置。
功能
外部存储合并排序
列出临时文件
打开临时文件
读取标题
计算标题中要排序的列的位置。
写出标题
读课文的第一行。
维护k个元素的列表并存储k个排序的列值。
按升序排序和维护列表，按降序反转。
写出最小值对应的行。
阅读文档并处理文档。
如果您还没有读完文档
更新列表周期计算
所有文件看完了。
功能
外部存储器分类
创建一个临时文件目录
读取要排序的分段文件。
分段排序
按顺序写文件。
外部存储合并排序
删除临时目录
主程序
调用外部存储器排序函数
在这里，外部存储器排序是通过合并和逐行写入来完成的。因为熊猫逐行读取的效率很低，所以熊猫没有办法逐行合并排序。如果读者有兴趣，可以尝试用熊猫分块合并，比较一下效率。
相比聚合和过滤，这段代码相当复杂，对于很多非专业程序员来说是不可能完成的任务，运行效率也不高。
上面的代码只处理标准化的结构化文件和单列排序。如果文件结构不规范，比如没有表头，每行分隔符个数不同，排序列的日期格式不规范或者按多列排序，代码会进一步复杂化。
四。分组
大文件分组汇总也很麻烦。一种简单的方法是首先通过对列进行分组来对文件进行排序，然后遍历排序后的文件。如果分组列值与上一行相同，则在同一组中汇总，如果与上一行不同，则创建一个新组继续汇总。如果结果集过大，则视情况而定，及时写出计算出的分组结果。
这种算法比较简单，但是性能很差，需要经历一个很大的排序过程。一般数据库会使用哈希分组方案，可以有效提高速度，但是代码复杂度要高几倍。一般非专业人士基本不可能写出来。这里就不列举代码了。
从上面的介绍我们知道Python处理大文件还是很费力的，主要是因为它没有提供大数据服务的游标类型和相关操作，只能自己写代码，不仅繁琐而且效率低下。
Python不方便，那么还有哪些适合非专业程序员处理大文件的工具呢？
在这方面，EsProc SPL比Python方便得多。SPL是一种专业的结构化数据处理语言，它提供了比熊猫更丰富的操作。有了内置的游标数据类型，解决大文件的操作就非常简单了。比如上面的例子就可以轻松完成。
一.聚合
第二，过滤
第三，排序
四。分组
特别指出SPL的分组汇总是基于数据库常用的哈希算法，效率高。
并行计算也内置于SPL中。现在多核CPU非常普遍。使用并行计算可以大大提高性能，例如分组和汇总。只加一个@ m就可以变成并行计算。
而Python，写并行计算程序太难了。网上有各种各样的事情，但是没有简单的方法去做。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。