python的open打开的是哪里的文件啊_百度知道
python的open打开的是哪里的文件啊
可是我自己建一个比如txt格式的然后打开就提示错误了;r&#39，&#39我看书上，直接就可以按照open(文件名;)打开了，只要有个文件
提问者采纳
;文件名&#39提示的是什么错误啊.abspath(&quot：可能是语法错误，通常是按文本格式打开.path，少了引号，可以用这句话知道你的当前目录import os。 如果你启动了python。 open(&#39。它缺省只能打开当前目录.&。 如果是打开错误;)用这个方法打开;r&#39，&#39，也可能是你因为你没有指定好路径。getcwd似乎是这样有几个，也可能是你的反斜杠没有加转义的\) 当然还有其它的办法知道当前目录。你贴过来看看
来自团队：
其他类似问题
7人觉得有用
/foo。最后;rb'home&#47如果文件名是相对路径名;foo$ ：$ pwd&#47。当前路径默认是你启动程序的目录;home/home/，“当前路径”应该是/foo..getcwd()获得当前路径，而不是/)打开的是&#47.chdir()来改变当前路径;bin&#47，例如;foo&#47，也可以利用goo&#47，如果你读某文件没有访问权限;file.txt，则open('goo/home/bin在程序中, &#39，open也是会报错的（错误信息会详细提示原因）.txt&#39。假设当前路径为/home&#47，可以通过file.py此时，则是以当前目录为基点的路径名
来自团队：
为您推荐：
其他2条回答
果你想以文件名打开的话：r&quot；如果不在同一文件夹内，如;Data&#92.txt&C，则需要使用全路径，要把这个文件放在你python文件同一文件夹内:&#92
你文件路径没有写吧
您可能关注的推广
python的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁&& 查看话题
帮忙看下这个python程序啊，运行没错误，但就是没结果，求指导
我的题目是这样的，改写数据格式，数据如下：
&xxxxxxxxxxxxxx
yyyyyyyyyyyyyyyyyyyyy
yyyyyyyyyyyyyyyyyy
yyyyyyyyyyyyy
&xxxxxxxxxxxxxx
yyyyyyyyyyyyyyyy
yyyyyyyyyyyyyyyyyyyyyy
yyyyyyyyyyy
&xxxxxxxxxxxxxxxx
&xxxxxxxxxx
其中都有一个以大于号开头的标题行，接下来的序列，但是其中有空序列的（只有标题，没有序列），有空行的，还有重复的。还有就是有的序列含有除外的非法字符。
要求：删除重复（标题行相同即可），空行，序列每行写入70个字符，序列间空一行，含有非法字符的序列删掉。
我写的程序是这样的：
#!/usr/bin/env python
sequence =
titlelist =
title = None
fout = open('out_05.fa','w')
def is_valid_seq(seq):
& & if set(seq).issubset(set()):
& & & & fout.write('%s'%seq)
def no_repeat(title):
& & for title in titlelist:
& & & & if titlelist.count(title) == 1:
& & & && &&&fout.write('%s'%title)
def Main():
& & for line in open('src.fa','r'):
& & & & if line.startswith('&'):
& & & && &&&title = line
& & & && &&&no_repeat(title)
& & & & elif not line.strip():
& & & && &&&continue
& & & & else :
& & & && &&&seq = line
& & & && &&&if is_valid_seq(seq):& & & && &&&
& & & & & & & & if&&no_repeat(seq):
& & & & & & & && &&&seq.append(line.rstrip())
& & & & & & & && &&&segs = ''.join(seq)
& & & & & & & && &&&seqlist = segs.split()
& && &&&& & & && &&&for n in range(len(seqlist)):
& & & & & & & & & & & & if(n%70==0):
& & & & & & & & & & & && &&&sequence = sequence +&&+ ]
& & & & & & & & & & & & else:
& & & & & & & & & & & && &&&sequence = sequence + seqlist
& & & & & & & & & & & && &&&fout.write('%s'%sequence)
& & del seq
& & del sequence
fout.write('%s%s\r\n' % (title,sequence))
fout.close()
没有语法错误了，但就是没有结果，着急啊，请哪位大神帮忙看看啊，不胜感激！
是基因序列?楼主你上传你的src.fa文件才好测试啊,否则只能看意思写一个,你自己测试.
1.空行跳过
2.已有title的序列跳过
3.无内容空序列跳过
4.含有非法字符序列跳过
5.输出文件序列之间添加空行
6.序列输出长度最多70
7.原序列先后顺序不变
# output results: a dict
# title1: seq
output = {}
# keep title order
title = ''
# read content
for line in open('src.fa','r'):
& & sline = line.strip()
& & if len(sline)==0: continue # jump empty line
& & if sline.startswith('&'):
& && &&&# not the first title, save previous one
& && &&&if len(title)!=0 and title not in titles and len(seq)&0: # check and save
& && && && && & output = seq
& && && && && & titles.append(title)
& && &&&title = sline& &# save current title
& && &&&seq =& && && &# clear seq
& & elif set(sline.lower())==set('atcg'): # seq only has atcg
& && &&&seq.append(sline)
# output content
# line length
length = 70
for t in titles:
& & seq = ''.join(output)
& & result.append(t+'\n'+'\n'.join( for i in range(0,len(seq),length)]))
# write file
fout =&&open('out_05.fa','w')
fout.write('\n\n'.join(result))
fout.close()
print 'DONE'
&test1(illegal letters)
atcqATCQadkfaldfjaldasnlfnaldkjfaldkjflafjdfalidjLKJLIJILNLKJKLJLJLJIOJLJLJKIOJLJLKJKJKLJLKJ
&test2(OK, length is bigger than 70)
ATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaTCG
&test3(no empty line, illegal letters)
aadfalskdfaakd
&test4(empty seq)
&test5(duplicate title)
&test5(duplicate title)
&test2(OK)
ATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaTCGATCGatcgaT
CGATCGatcgaTCG
&test5(duplicate title)
atcg : Originally posted by libralibra at
是基因序列?楼主你上传你的src.fa文件才好测试啊,否则只能看意思写一个,你自己测试.
1.空行跳过
2.已有title的序列跳过
3.无内容空序列跳过
4.含有非法字符序列跳过
5.输出文件序列之间添加空行
6.序列输出长 ... :victory:
真的很佩服你啊，果然厉害，你的脚步脚本运行完全正确！
不过我有些不懂的：
1.if len(title)!=0 and title not in titles and len(seq)&0: # check and save
& && && && && & output = seq
& && && && && & titles.append(title)
比如这一句，虽然定义了 output是一个字典，但是你怎么指定连续的一个带大于号的标题行，与接下来的序列，联系起来呢，就是作为字典的key,value调用的？
2.result.append(t+'\n'+'\n'.join( for i in range(0,len(seq),length)]))
这个其中的 \n是要换行的吧，为什么要连续两个呢，并且都是\n,为什么不用\r呢？不知道这两个有什么区别，分别在什么时候用？
3.整天来说，你写的已经很完美了，很谢谢你。
我看了你的个人资料上有QQ:,能不能加你好友呢？十分感谢！ : Originally posted by luck_cc at
真的很佩服你啊，果然厉害，你的脚步脚本运行完全正确！
不过我有些不懂的：
1.if len(title)!=0 and title not in titles and len(seq)&0: # check and save
& && && && && & output = seq
& & ... 1这个默认了你的序列没有乱存,也就是title下面肯定是同一个的seq,同一个seq的内容之间不会有空行.否则可能需要多些判断.只要满足条件,读到&title的时候,有2种情况,要么是第一次进入(以前titia是空),要么title已经有值(前一个),
1.1 如果是第一次进入,保存title,清空seq准备接受序列;
1.2 如果不是第一次,那么title已经有值,seq也有值(可能是空),就写入结果到字典.但是如果title已经有(重复),seq是空(序列为空)或者title是空的时候不写入.然后保存当前title,清空seq准备接受序列内容.
2.python一般都用\n表示换行,result.append的时候,写完title需要换行.第二个换行符用来连接seq内容,这是python的'str'.join()函数.
qq一般不上,可以qq邮件. : Originally posted by libralibra at
1这个默认了你的序列没有乱存,也就是title下面肯定是同一个的seq,同一个seq的内容之间不会有空行.否则可能需要多些判断.只要满足条件,读到&title的时候,有2种情况,要么是第一次进入(以前titia是空),要么title已 ... 不好意思，关于第一个问题，我还是不太懂。原数据是规则的，每一个title下面是自己的seq，或者空行，但是，没有哪显示指定了他们之间的关系，怎么就赋给了字典中的对应key-value对呢？ : Originally posted by luck_cc at
不好意思，关于第一个问题，我还是不太懂。原数据是规则的，每一个title下面是自己的seq，或者空行，但是，没有哪显示指定了他们之间的关系，怎么就赋给了字典中的对应key-value对呢？... if len(sline)==0: continue # jump empty line
& & if sline.startswith('&'):
& && &&&# not the first title, save previous one
& && &&&if len(title)!=0 and title not in titles and len(seq)&0: # check and save
& && && && && & output = seq
& && && && && & titles.append(title)
& && &&&title = sline& &# save current title
& && &&&seq =& && && &# clear seq
& & elif set(sline.lower())==set('atcg'): # seq only has atcg
& && &&&seq.append(sline)
主要看这几行
就是认为title下面肯定是对应的seq,才判断当前行是不是以&开头,如果是就记录title,如果不是,读取内容到seq.等到下次读取到title的时候,原来的title和seq不就是上一个对应关系吗?记录之后修改title,然后清空seq准备读取下一对. : Originally posted by libralibra at
if len(sline)==0: continue # jump empty line
& & if sline.startswith('&'):
& && &&&# not the first title, save previous one
& && &&&if len(title)!=0 and title not in titles and len(seq)&0:&&... if sline.startswith('&'):
& && &&&# not the first title, save previous one
if len(title)!=0 and title not in titles and len(seq)&0: # check and save
这一行，有些疑问：
这个是刚开始判断，就是读取每一行，然后去掉两端空格，记为 sline对吧。
如果 sline是以大于号开始，把它赋给title，但是这个赋值是第二行的判断之后。
我不明白，第二个if判断的时候，还没有赋值，怎么就有title，和seq了呢？ : Originally posted by libralibra at
if len(sline)==0: continue # jump empty line
& & if sline.startswith('&'):
& && &&&# not the first title, save previous one
& && &&&if len(title)!=0 and title not in titles and len(seq)&0:&&... 还有这个：
if len(title)!=0 and title not in titles and len(seq)&0: # check and save
& && && && && & output = seq
第二句，当前判断的还是title对吧，即使写的是seq。我自己这么判断的，不知道对不对？
那这个赋值就看不懂了， output = seq，是把当前读的序列赋给 了title呢，还是字典中title对应的value呢，关于字典的用法，还不是很清楚。 : Originally posted by luck_cc at
if sline.startswith('&'):
& && &&&# not the first title, save previous one
if len(title)!=0 and title not in titles and len(seq)&0: # check and save
这一行，有些疑问：
这个是刚开始判断， ... # title
title = ''
循环开始前不是初始化了吗?title只有第一次读取到&开始的行才是空的,以后永远是上一次的title值.seq每次读完新的title都清空,但是假如的时候,如果序列是空的就跳过,不添加到字典了. : Originally posted by luck_cc at
还有这个：
if len(title)!=0 and title not in titles and len(seq)&0: # check and save
& && && && && & output = seq
第二句，当前判断的还是title对吧，即使写的是seq。我自己这么判断的，不知道对不对 ... python 的数据结构就那么几种,常用的也就list,dict(tuple大多数时候基本可以不用,string算个数据格式吧),多写些代码就熟练了.
字典的关系: 字典名 = value : Originally posted by libralibra at
python 的数据结构就那么几种,常用的也就list,dict(tuple大多数时候基本可以不用,string算个数据格式吧),多写些代码就熟练了.
字典的关系: 字典名 = value... 嗯，很谢谢你了，送你一朵小红花！
你有空的话，能不能看下我写的那个程序呢，不知道哪里错了，该怎么修改？
这是我第一次写代码，花了很长时间才写成这样，还没有结果，所以想把这个修改好，谢谢你了。
以后会多加练习的。1. Python是一门解释型语言？
我初学Python时，听到的关于Python的第一句话就是，Python是一门解释性语言，我就这样一直相信下去，直到发现了*.pyc文件的存在。如果是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！
为了防止其他学习Python的人也被这句话误解，那么我们就在文中来澄清下这个问题，并且把一些基础概念给理清。
2. 解释型语言和编译型语言
计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释。
编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。
解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。
通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。
此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。
用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。
再换成C#，C#首先是通过编译器将C#文件编译成IL文件，然后在通过CLR将IL文件编译成机器文件。所以我们说C#是一门纯编译语言，但是C#是一门需要二次编译的语言。同理也可等效运用到基于.NET平台上的其他语言。
3. Python到底是什么
其实Python和Java/C#一样，也是一门基于虚拟机的语言，我们先来从表面上简单地了解一下Python程序的运行过程吧。
当我们在命令行中输入python hello.py时，其实是激活了Python的“解释器”，告诉“解释器”：你要开始工作了。可是在“解释”之前，其实执行的第一项工作和Java一样，是编译。
熟悉Java的同学可以想一下我们在命令行中如何执行一个Java的程序：
javac hello.java
java hello
只是我们在用Eclipse之类的IDE时，将这两部给融合成了一部而已。其实Python也一样，当我们执行python hello.py时，他也一样执行了这么一个过程，所以我们应该这样来描述Python，Python是一门先编译后解释的语言。
4. 简述Python的运行过程
在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。
我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。
5. 运行一段Python程序
我们来写一段程序实际运行一下：
程序本身毫无意义。我们继续看：
然而我们在程序中并没有看到pyc文件，仍然是test.py孤零零地呆在那！
那么我们换一种写法，我们把print_str方法换到另外的一个python模块中：
然后运行程序：
这个时候pyc文件出现了，其实认真思考一下不难得到原因，我们考虑一下实际的业务情况。
6. pyc的目的是重用
回想本文的第二段在解释编译型语言和解释型语言的优缺点时，我说编译型语言的优点在于，我们可以在程序运行时不用解释，而直接利用已经“翻译”过的文件。也就是说，我们之所以要把py文件编译成pyc文件，最大的优点在于我们在运行程序时，不需要重新对该模块进行重新的解释。
所以，我们需要编译成pyc文件的应该是那些可以重用的模块，这于我们在设计软件类时是一样的目的。所以Python的解释器认为：只有import进来的模块，才是需要被重用的模块。
这个时候也许有人会说，不对啊！你的这个问题没有被解释通啊，我的test.py不是也需要运行么，虽然不是一个模块，但是以后我每次运行也可以节省时间啊！
OK，我们从实际情况出发，思考下我们在什么时候才可能运行python xxx.py文件：
A. 执行测试时。
B. 开启一个Web进程时。
C. 执行一个程序脚本。
我们逐个来说，第一种情况我们就不用多说了，这个时候哪怕所有的文件都没有pyc文件都是无所谓的。
第二种情况，我们试想一个webpy的程序把，我们通常这样执行：
然后这个程序就类似于一个守护进程一样一直监视着端口，而一旦中断，只可能是程序被杀死，或者其他的意外情况，那么你需要恢复要做的是把整个的Web服务重启。那么既然一直监视着，把PyCodeObject一直放在内存中就足够了，完全没必要持久化到硬盘上。
最后一个情况，执行一个程序脚本，一个程序的主入口其实很类似于Web程序中的Controller，也就是说，他负责的应该是Model之间的调度，而不包含任何的主逻辑在内，如我在中所提到，Controller应该就是一个Facade，无任何的细节逻辑，只是把参数转来转去而已，那么如果做算法的同学可以知道，在一段算法脚本中，最容易改变的就是算法的各个参数，那么这个时候给持久化成pyc文件就未免有些画蛇添足了。
所以我们可以这样理解Python解释器的意图，Python解释器只把我们可能重用到的模块持久化成pyc文件。
7. pyc的过期时间
说完了pyc文件，可能有人会想到，每次Python的解释器都把模块给持久化成了pyc文件，那么当我的模块发生了改变的时候，是不是都要手动地把以前的pyc文件remove掉呢？
当然Python的设计者是不会犯这么白痴的错误的。而这个过程其实就取决于PyCodeObject是如何写入pyc文件中的。
我们来看一下import过程的源码吧：
这段代码比较长，我们只来看我标注了的代码，其实他在写入pyc文件的时候，写了一个Long型变量，变量的内容则是文件的最近修改日期，同理，我们再看下载入pyc的代码：
不用仔细看代码，我们可以很清楚地看到原理，其实每次在载入之前都会先检查一下py文件和pyc文件保存的最后修改日期，如果不一致则重新生成一份pyc文件。
8. 写在最后的
其实了解Python程序的执行过程对于大部分程序员，包括Python程序员来说意义都是不大的，那么真正有意义的是，我们可以从Python的解释器的做法上学到什么，我认为有这样的几点：
A. 其实Python是否保存成pyc文件和我们在设计缓存系统时是一样的，我们可以仔细想想，到底什么是值得扔在缓存里的，什么是不值得扔在缓存里的。
B. 在跑一个耗时的Python脚本时，我们如何能够稍微压榨一些程序的运行时间，就是将模块从主模块分开。（虽然往往这都不是瓶颈）
C. 在设计一个软件系统时，重用和非重用的东西是不是也应该分开来对待，这是软件设计原则的重要部分。
D. 在设计缓存系统（或者其他系统）时，我们如何来避免程序的过期，其实Python的解释器也为我们提供了一个特别常见而且有效的解决方案。
阅读(...) 评论()