Quiero redirigir la impresión a un archivo .txt usando python. Tengo un bucle 'for', que 'imprimirá' la salida de cada uno de mis archivos .bam mientras quiero redirigir TODAS estas salidas a un archivo. Entonces traté de poner

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

Al principio de mi guión. Sin embargo, no obtengo nada en el archivo .txt. Mi guión es:

#!/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....

¿Entonces, cuál es el problema? ¿De alguna otra manera además de este sys.stdout?

Necesito que mi resultado se vea así:

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

La forma más obvia de hacer esto sería imprimir en un objeto de archivo:

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

Sin embargo, redireccionar stdout también funciona para mí. Probablemente esté bien para un script único como este:

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()

Redirigir externamente desde el propio shell es otra buena opción:

./script.py > out.txt

Otras preguntas:

¿Cuál es el primer nombre de archivo en su script? No lo veo inicializado.

Mi primera suposición es que glob no encuentra ningún archivo bam y, por lo tanto, el bucle for no se ejecuta. Compruebe que la carpeta existe e imprima archivos bam en su secuencia de comandos.

Además, use os.path.join y os.path.basename para manipular rutas y nombres de archivos.

Puede redirigir la impresión con el >>operador.

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

En la mayoría de los casos, es mejor simplemente escribir en el archivo normalmente.

f.write('whatever')

o, si tiene varios elementos que desea escribir con espacios entre ellos, como print:

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

Referencia de API de Python 2 o Python 3 :

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

El argumento del archivo debe ser un objeto con un write(string)método; si no está presente o None, sys.stdoutse utilizará. Como los argumentos impresos se convierten en cadenas de texto, print()no se pueden usar con objetos de archivo en modo binario. Para estos, use file.write(...)en su lugar.

Dado que el objeto de archivo normalmente contiene un write()método, todo lo que necesita hacer es pasar un objeto de archivo a su argumento.

Escribir / sobrescribir en archivo

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

Escribir / agregar al archivo

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

Esto funciona perfectamente:

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

Ahora el saludo se escribirá en el archivo test.txt. Asegúrese de cerrar el archivo stdoutcon a close, sin él el contenido no se guardará en el archivo

No uses print, usalogging

Puede cambiar sys.stdoutpara apuntar a un archivo, pero esta es una forma bastante torpe e inflexible de manejar este problema. En lugar de usar print, use el loggingmódulo.

Con logging, puede imprimir como lo haría stdout, o también puede escribir la salida en un archivo. Usted puede incluso utilizar los diferentes niveles de mensaje ( critical, error, warning, info, debug) para, por ejemplo, sólo imprimir las principales cuestiones a la consola, pero aún así registrar las acciones de código de menor importancia a un archivo.

Un simple ejemplo

Importe logging, obtenga loggery establezca el nivel de procesamiento:

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

Si desea imprimir en stdout:

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

Si también desea escribir en un archivo (si solo desea escribir en un archivo, omita la última sección):

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

Luego, donde sea que use printusar uno de los loggermétodos:

# 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')

Para obtener más información sobre el uso de loggingfunciones más avanzadas , lea el excelente loggingtutorial en los documentos de Python .

La solución más fácil no es a través de Python; es a través de la concha. Desde la primera línea de su archivo ( #!/usr/bin/python) supongo que está en un sistema UNIX. Simplemente use printdeclaraciones como lo haría normalmente, y no abra el archivo en absoluto en su script. Cuando vayas a ejecutar el archivo, en lugar de

./script.py

para ejecutar el archivo, use

./script.py > <filename>

donde reemplaza <filename>con el nombre del archivo al que desea que vaya la salida. El >token le dice a (la mayoría) los shells que establezcan stdout en el archivo descrito por el siguiente token.

Una cosa importante que debe mencionarse aquí es que "script.py" debe hacerse ejecutable para ./script.pyejecutarse.

Entonces, antes de ejecutar ./script.py, ejecute este comando

chmod a+x script.py (hacer que el script sea ejecutable para todos los usuarios)

Si está utilizando Linux, le sugiero que use el teecomando. La implementación es así:

python python_file.py | tee any_file_name.txt

Si no desea cambiar nada en el código, creo que esta podría ser la mejor solución posible. También puede implementar el registrador, pero necesita hacer algunos cambios en el código.

Puede que no te guste esta respuesta, pero creo que es la CORRECTA. No cambie su destino stdout a menos que sea absolutamente necesario (tal vez esté usando una biblioteca que solo da salida a stdout, claramente no es el caso aquí).

Creo que, como buen hábito, debe preparar sus datos con anticipación como una cadena, luego abrir su archivo y escribir todo de una vez. Esto se debe a que las operaciones de entrada / salida son cuanto más tiempo tenga abierto un identificador de archivo, es más probable que ocurra un error con este archivo (error de bloqueo de archivo, error de E / S, etc.). Simplemente hacerlo todo en una sola operación no deja dudas sobre cuándo podría haber salido mal.

Aquí hay un ejemplo:

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')

Y luego, cuando haya terminado de recopilar sus "líneas de datos" una línea por elemento de la lista, puede unirlas con algunos '\n'caracteres para que todo se pueda generar; tal vez incluso envuelva su declaración de salida en unwith bloque, para mayor seguridad (cerrará automáticamente su identificador de salida incluso si algo sale mal):

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!!!"

Sin embargo, si tiene muchos datos para escribir, puede escribirlos de a uno por vez. No creo que sea relevante para su aplicación, pero esta es la alternativa:

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()

Si la redirección stdoutfunciona para su problema, la respuesta de Gringo Suave es una buena demostración de cómo hacerlo.

Para hacerlo aún más fácil , hice una versión utilizando contextmanagers para una sintaxis de llamada generalizada sucinta usando la withdeclaración:

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

Para usarlo, simplemente haga lo siguiente (derivado del ejemplo de Suave):

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

Es útil para redirigir selectivamente printcuando un módulo lo usa de una manera que no le gusta. La única desventaja (y este es el factor decisivo para muchas situaciones) es que no funciona si uno quiere múltiples hilos con diferentes valores de stdout, pero eso requiere un método mejor y más generalizado: acceso indirecto al módulo. Puede ver implementaciones de eso en otras respuestas a esta pregunta.

Cambiar el valor de sys.stdout cambia el destino de todas las llamadas a imprimir. Si utiliza una forma alternativa de cambiar el destino de la impresión, obtendrá el mismo resultado.

Tu error está en otro lugar:

• podría estar en el código que eliminó para su pregunta (¿de dónde proviene el nombre de archivo para que se abra la llamada?)
• También podría ser que no está esperando que se vacíen los datos: si imprime en un terminal, los datos se vacían después de cada nueva línea, pero si imprime en un archivo, solo se vacían cuando el búfer stdout está lleno (4096 bytes en la mayoría de los sistemas).

Algo para extender la función de impresión para bucles

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