Yazdırmayı python kullanarak bir .txt dosyasına yeniden yönlendirmek istiyorum. TÜM bu çıktıyı tek bir dosyaya yeniden yönlendirmek istediğinizde '.' Döngümün her biri için çıktıyı yazdıracak bir 'for' döngüsü var. Bu yüzden koymaya çalıştım

 f = open('output.txt','w'); sys.stdout = f

senaryomun başında. Ancak .txt dosyasında hiçbir şey almıyorum. Benim senaryom:

#!/usr/bin/python

import os,sys
import subprocess
import glob
from os import path

f = open('output.txt','w')
sys.stdout = f

path= '/home/xug/nearline/bamfiles'
bamfiles = glob.glob(path + '/*.bam')

for bamfile in bamfiles:
    filename = bamfile.split('/')[-1]
    print 'Filename:', filename
    samtoolsin = subprocess.Popen(["/share/bin/samtools/samtools","view",bamfile],
                                  stdout=subprocess.PIPE,bufsize=1)
    linelist= samtoolsin.stdout.readlines()
    print 'Readlines finished!'
    ........print....
    ........print....

Peki sorun ne? Bu sys.stdout dışında başka bir yol var mı?

Benim sonuç bakmak gerekir:

Filename: ERR001268.bam
Readlines finished!
Mean: 233
SD: 10
Interval is: (213, 252)

Bunu yapmanın en belirgin yolu bir dosya nesnesine yazdırmak olacaktır:

with open('out.txt', 'w') as f:
    print >> f, 'Filename:', filename     # Python 2.x
    print('Filename:', filename, file=f)  # Python 3.x

Ancak, stdout'u yeniden yönlendirmek de benim için çalışıyor. Muhtemelen böyle bir kerelik bir komut dosyası için iyidir:

import sys

orig_stdout = sys.stdout
f = open('out.txt', 'w')
sys.stdout = f

for i in range(2):
    print 'i = ', i

sys.stdout = orig_stdout
f.close()

Kabuğun kendisinden dışarıdan yönlendirme başka bir iyi seçenektir:

./script.py > out.txt

Diğer sorular:

Senaryonuzdaki ilk dosya adı nedir? Başladığını görmüyorum.

İlk tahminim, glob'un herhangi bir bamfile bulamadığı ve bu nedenle for döngüsü çalışmadığıdır. Klasörün var olup olmadığını kontrol edin ve komut dosyasındaki bamfiles dosyalarını yazdırın.

Ayrıca yolları ve dosya adlarını değiştirmek için os.path.join ve os.path.basename öğelerini kullanın.

Baskıyı >>operatörle yeniden yönlendirebilirsiniz .

f = open(filename,'w')
print >>f, 'whatever'     # Python 2.x
print('whatever', file=f) # Python 3.x

Çoğu durumda, dosyaya normal olarak yazmanız daha iyi olur.

f.write('whatever')

veya aralarında boşluklar ile yazmak istediğiniz birkaç öğeniz varsa, örneğin print:

f.write(' '.join(('whatever', str(var2), 'etc')))

Python 2 veya Python 3 API referansı:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Dosya bağımsız değişkeni içeren bir nesne olmalıdır write(string)yöntem; Mevcut değilse veya None, sys.stdoutkullanılacaktır. Yazdırılan bağımsız değişkenler metin dizelerine dönüştürüldüğünden, print()ikili mod dosya nesneleriyle kullanılamaz. Bunlar için file.write(...)kullanın.

Yana dosya nesnesi normalde içeren write()yöntemi, yapmanız gereken tek şey bir geçmektir dosya nesnesini onun argüman haline.

Dosyaya Yazma / Üzerine Yazma

with open('file.txt', 'w') as f:
    print('hello world', file=f)

Dosyaya Yazma / Dosyaya Ekleme

with open('file.txt', 'a') as f:
    print('hello world', file=f)

Mükemmel çalışıyor:

import sys
sys.stdout=open("test.txt","w")
print ("hello")
sys.stdout.close()

Şimdi merhaba test.txt dosyasına yazılır. Kapatmak için emin olun stdoutbir ile closedosyadaki tasarruf olmayacak onsuz, içeriği

Kullanma print, kullanmalogging

sys.stdoutBir dosyayı işaret edecek şekilde değiştirebilirsiniz , ancak bu, bu sorunu ele almanın oldukça karmaşık ve esnek olmayan bir yoludur. Kullanmak yerine modülü printkullanın logging.

İle loggingaynen yaptığınız gibi yazdırabilir stdoutveya çıktıyı bir dosyaya yazabilirsiniz. Hatta (farklı mesaj seviyeleri kullanabilir critical, error, warning, info, debug), örneğin, sadece konsola ana meseleleri yazdırmak için, ama yine de bir dosyaya küçük kod eylemleri log.

Basit bir örnek

İşleme seviyesini içe aktarın logging, alın loggerve ayarlayın:

import logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG) # process everything, even if everything isn't printed

Stdout'a yazdırmak istiyorsanız:

ch = logging.StreamHandler()
ch.setLevel(logging.INFO) # or any other level
logger.addHandler(ch)

Bir dosyaya da yazmak istiyorsanız (yalnızca bir dosyaya yazmak istiyorsanız son bölümü atlayın):

fh = logging.FileHandler('myLog.log')
fh.setLevel(logging.DEBUG) # or any level you want
logger.addHandler(fh)

Ardından, nerede kullanırsanız printkullanın loggeryöntemlerden birini kullanın :

# print(foo)
logger.debug(foo)

# print('finishing processing')
logger.info('finishing processing')

# print('Something may be wrong')
logger.warning('Something may be wrong')

# print('Something is going really bad')
logger.error('Something is going really bad')

Daha gelişmiş loggingözellikleri kullanma hakkında daha fazla bilgi edinmek loggingiçin Python belgelerindeki mükemmel eğitimi okuyun .

En kolay çözüm python ile değil; kabuğun içinden. Dosyanızın ilk satırından ( #!/usr/bin/python) UNIX sisteminde olduğunuzu tahmin ediyorum. Sadece printnormalde yaptığınız gibi ifadeler kullanın ve dosyayı betiğinizde hiç açmayın. Dosyayı çalıştırmak için gittiğinizde,

./script.py

dosyayı çalıştırmak için şunu kullanın:

./script.py > <filename>

<filename>çıktının girmesini istediğiniz dosyanın adıyla değiştirirsiniz . >Belirteci aşağıdaki belirteç ile tarif dosyaya grubu Stdout'a (en) kabukları anlatır.

Burada belirtilmesi gereken önemli bir şey, "script.py" nin çalıştırılabilmesi için ./script.pyçalıştırılabilir hale getirilmesi gerektiğidir .

Bu yüzden çalıştırmadan önce ./script.pybu komutu yürütün

chmod a+x script.py (komut dosyasını tüm kullanıcılar için yürütülebilir hale getirin)

Linux kullanıyorsanız teekomutu kullanmanızı öneririm . Uygulama şu şekildedir:

python python_file.py | tee any_file_name.txt

Koddaki hiçbir şeyi değiştirmek istemiyorsanız, bunun mümkün olan en iyi çözüm olabileceğini düşünüyorum. Günlükçü de uygulayabilirsiniz, ancak kodda bazı değişiklikler yapmanız gerekir.

Bu yanıtı beğenmeyebilirsiniz, ama bence bu doğru. Kesinlikle gerekli olmadıkça stdout hedefinizi değiştirmeyin (belki sadece stdout için çıktı veren bir kütüphane kullanıyorsunuz ??? burada açıkça değil).

İyi bir alışkanlık olarak, verilerinizi bir dize olarak önceden hazırlamalı, sonra dosyanızı açmalı ve her şeyi aynı anda yazmalısınız. Bunun nedeni, giriş / çıkış işlemlerinin dosya tanıtıcısı ne kadar uzun süre açık kalmasıdır, bu dosyada (dosya kilitleme hatası, i / o hatası, vb.) Bir hata oluşması daha olasıdır. Hepsini tek bir işlemde yapmak, ne zaman yanlış gittiğine dair bir soru bırakmaz.

İşte bir örnek:

out_lines = []
for bamfile in bamfiles:
    filename = bamfile.split('/')[-1]
    out_lines.append('Filename: %s' % filename)
    samtoolsin = subprocess.Popen(["/share/bin/samtools/samtools","view",bamfile],
                                  stdout=subprocess.PIPE,bufsize=1)
    linelist= samtoolsin.stdout.readlines()
    print 'Readlines finished!'
    out_lines.extend(linelist)
    out_lines.append('\n')

Ve sonra "veri satırlarınızı" liste öğesi başına bir satır '\n'toplamayı tamamladığınızda, her şeyi çıktı haline getirmek için bunlara bazı karakterlerle katılabilirsiniz; hatta withek güvenlik için çıktı ifadenizi bir bloğa sarın (bir şeyler ters giderse bile çıktı tutamacınızı otomatik olarak kapatır):

out_string = '\n'.join(out_lines)
out_filename = 'myfile.txt'
with open(out_filename, 'w') as outf:
    outf.write(out_string)
print "YAY MY STDOUT IS UNTAINTED!!!"

Eğer yazma veri çok var ancak bunu verebilir bunu bir seferde bir parça yazmak. Başvurunuzla alakalı olduğunu düşünmüyorum, ancak alternatif:

out_filename = 'myfile.txt'
outf = open(out_filename, 'w')
for bamfile in bamfiles:
    filename = bamfile.split('/')[-1]
    outf.write('Filename: %s' % filename)
    samtoolsin = subprocess.Popen(["/share/bin/samtools/samtools","view",bamfile],
                                  stdout=subprocess.PIPE,bufsize=1)
    mydata = samtoolsin.stdout.read()
    outf.write(mydata)
outf.close()

Yeniden yönlendirme stdoutsorununuz için işe yarıyorsa , Gringo Suave'in cevabı bunun nasıl yapılacağı için iyi bir gösteri.

Daha da kolaylaştırmak için, ifadeyi kullanarak özlü bir genelleştirilmiş çağrı sözdizimi için bağlam yöneticilerini kullanan bir sürüm yaptım with:

from contextlib import contextmanager
import sys

@contextmanager
def redirected_stdout(outstream):
    orig_stdout = sys.stdout
    try:
        sys.stdout = outstream
        yield
    finally:
        sys.stdout = orig_stdout

Kullanmak için aşağıdakileri yapmanız yeterlidir (Suave'in örneğinden türetilmiştir):

with open('out.txt', 'w') as outfile:
    with redirected_stdout(outfile):
        for i in range(2):
            print('i =', i)

printBir modül onu sevmediğiniz bir şekilde kullandığında seçici olarak yeniden yönlendirmek için kullanışlıdır . Tek dezavantajı (ve bu birçok durum için dağıtıcıdır), biri farklı değerlere sahip birden çok iş parçacığı istiyorsa işe yaramaz stdout, ancak daha iyi, daha genel bir yöntem gerektirir: dolaylı modül erişimi. Bunun uygulamalarını bu sorunun diğer cevaplarında görebilirsiniz.

Sys.stdout değerinin değiştirilmesi, yazdırılacak tüm çağrıların hedefini değiştirir. Yazdırma hedefini değiştirmek için alternatif bir yol kullanırsanız, aynı sonucu alırsınız.

Hatanız başka bir yerde:

• sorunuz için kaldırdığınız kodda olabilir (çağrının açılması için dosya adı nereden gelir?)
• ayrıca verilerin temizlenmesini beklemiyor olabilirsiniz: bir terminale yazdırırsanız, veriler her yeni satırdan sonra temizlenir, ancak bir dosyaya yazdırırsanız, yalnızca stdout arabelleği dolduğunda temizlenir (4096 bayt) çoğu sistemde).

Döngüler için yazdırma işlevini genişletecek bir şey

x = 0
while x <=5:
    x = x + 1
    with open('outputEis.txt', 'a') as f:
        print(x, file=f)
    f.close()