file ejercicios - Cómo mover un archivo en Python




funcion copiar (9)

La respuesta aceptada no es la correcta, porque la pregunta no es acerca de cambiar el nombre de un archivo a un archivo, sino de mover muchos archivos a un directorio. shutil.move hará el trabajo, pero para este propósito os.rename es inútil (como se indica en los comentarios) porque el destino debe tener un nombre de archivo explícito.

Busqué en la interfaz del sistema operativo de Python, pero no pude encontrar un método para mover un archivo. ¿Cómo haría el equivalente de $ mv ... en Python?

>>> source_files = '/PATH/TO/FOLDER/*'
>>> destination_folder = 'PATH/TO/FOLDER'
>>> # equivalent of $ mv source_files destination_folder

  import os,shutil

  current_path = "" ## source path

  new_path = "" ## destination path

  os.chdir(current_path)

  for files in os.listdir():

        os.rename(files, new_path+'{}'.format(f))
        shutil.move(files, new_path+'{}'.format(f)) ## to move files from 

disco diferente ex. C: -> D:


Para el os.rename o shutil.move necesitará importar el módulo. No es necesario un carácter * para mover todos los archivos.

Tenemos una carpeta en / opt / awesome llamado origen con un archivo llamado awesome.txt.

in /opt/awesome
○ → ls
source
○ → ls source
awesome.txt

python 
>>> source = '/opt/awesome/source'
>>> destination = '/opt/awesome/destination'
>>> import os
>>> os.rename(source, destination)
>>> os.listdir('/opt/awesome')
['destination']

Usamos os.listdir para ver que el nombre de la carpeta de hecho cambió. Aquí está el cierre moviendo el destino de nuevo a la fuente.

>>> import shutil
>>> shutil.move(destination, source)
>>> os.listdir('/opt/awesome/source')
['awesome.txt']

Esta vez revisé dentro de la carpeta de origen para asegurarme de que el archivo awesome.txt que creé existe. Está ahí :)

Ahora hemos movido una carpeta y sus archivos de un origen a un destino y viceversa.


os.rename() o shutil.move()

Ambos emplean la misma sintaxis:

import os
import shutil

os.rename("path/to/current/file.foo", "path/to/new/destination/for/file.foo")
shutil.move("path/to/current/file.foo", "path/to/new/destination/for/file.foo")

Tenga en cuenta que en ambos casos el directorio en el que se está creando el nuevo archivo ya debe existir (pero, en Windows, no debe existir un archivo con ese nombre o se generará una excepción). También tenga en cuenta que debe incluir el nombre del archivo ( file.foo ) en los argumentos de origen y destino. Si se cambia, el nombre del archivo se cambiará y se moverá.

Como se ha señalado en los comentarios sobre otras respuestas, shutil.move simplemente llama os.rename en la mayoría de los casos. Sin embargo, si el destino está en un disco diferente al origen, en su lugar, copiará y luego eliminará el archivo de origen.



Esto es lo que estoy usando en este momento:

import os, shutil
path = "/volume1/Users/Transfer/"
moveto = "/volume1/Users/Drive_Transfer/"
files = os.listdir(path)
files.sort()
for f in files:
    src = path+f
    dst = moveto+f
    shutil.move(src,dst)

Ahora completamente funcional. Espero que esto te ayude.


Aunque os.rename() y shutil.move() cambiarán el nombre de los archivos, el comando más cercano al comando shutil.move() Unix es shutil.move() . La diferencia es que os.rename() no funciona si el origen y el destino están en discos diferentes, mientras que a shutil.move() no le importa en qué disco están los archivos.


Basado en la respuesta que se describe aquí , usar subprocess es otra opción.

Algo como esto:

subprocess.call("mv %s %s" % (source_files, destination_folder), shell=True)

Tengo curiosidad por saber los pros y shutil de este método en comparación con shutil . Ya que en mi caso ya estoy usando el subprocess por otras razones y parece funcionar, me inclino a seguirlo.

¿Es dependiente del sistema tal vez?


Función del __call__()método de una metaclase al crear una instancia de clase

Si ha realizado la programación en Python durante más de unos pocos meses, eventualmente se encontrará con un código que se ve así:

# define a class
class SomeClass(object):
    # ...
    # some definition here ...
    # ...

# create an instance of it
instance = SomeClass()

# then call the object as if it's a function
result = instance('foo', 'bar')

Esto último es posible cuando implementas el __call__()método mágico en la clase.

class SomeClass(object):
    # ...
    # some definition here ...
    # ...

    def __call__(self, foo, bar):
        return bar + foo

El __call__()método se invoca cuando una instancia de una clase se utiliza como una llamada. Pero como hemos visto en respuestas anteriores, una clase en sí misma es una instancia de una metaclase, por lo que cuando usamos la clase como llamable (es decir, cuando creamos una instancia de ella), en realidad estamos llamando al __call__()método de metaclase . En este punto, la mayoría de los programadores de Python están un poco confundidos porque se les ha dicho que cuando crean una instancia como esta instance = SomeClass(), están llamando a su __init__()método. Algunos que han cavado un poco más profundo saben que antes __init__()hay __new__(). Bueno, hoy se está revelando otra capa de verdad, antes de que __new__()exista la metaclase __call__().

Estudiemos la cadena de llamadas al método desde la perspectiva específica de crear una instancia de una clase.

Esta es una metaclase que registra exactamente el momento anterior a la creación de una instancia y el momento en que está a punto de devolverla.

class Meta_1(type):
    def __call__(cls):
        print "Meta_1.__call__() before creating an instance of ", cls
        instance = super(Meta_1, cls).__call__()
        print "Meta_1.__call__() about to return instance."
        return instance

Esta es una clase que usa esa metaclase.

class Class_1(object):

    __metaclass__ = Meta_1

    def __new__(cls):
        print "Class_1.__new__() before creating an instance."
        instance = super(Class_1, cls).__new__(cls)
        print "Class_1.__new__() about to return instance."
        return instance

    def __init__(self):
        print "entering Class_1.__init__() for instance initialization."
        super(Class_1,self).__init__()
        print "exiting Class_1.__init__()."

Y ahora vamos a crear una instancia de Class_1

instance = Class_1()
# Meta_1.__call__() before creating an instance of <class '__main__.Class_1'>.
# Class_1.__new__() before creating an instance.
# Class_1.__new__() about to return instance.
# entering Class_1.__init__() for instance initialization.
# exiting Class_1.__init__().
# Meta_1.__call__() about to return instance.

Observe que el código anterior no hace nada más que registrar las tareas. Cada método delega el trabajo real a la implementación de sus padres, manteniendo así el comportamiento predeterminado. Dado que typees Meta_1la clase padre ( typees la metaclase padre predeterminada) y teniendo en cuenta la secuencia de ordenamiento de la salida anterior, ahora tenemos una idea de cuál sería la pseudo implementación de type.__call__():

class type:
    def __call__(cls, *args, **kwarg):

        # ... maybe a few things done to cls here

        # then we call __new__() on the class to create an instance
        instance = cls.__new__(cls, *args, **kwargs)

        # ... maybe a few things done to the instance here

        # then we initialize the instance with its __init__() method
        instance.__init__(*args, **kwargs)

        # ... maybe a few more things done to instance here

        # then we return it
        return instance

Podemos ver que el __call__()método de metaclase es el que se llama primero. Luego delega la creación de la instancia al __new__()método de la clase y la inicialización a la instancia __init__(). También es el que finalmente devuelve la instancia.

De lo anterior se desprende que a la metaclase __call__()también se le da la oportunidad de decidir si se realizará o no una llamada Class_1.__new__()o Class_1.__init__()finalmente se realizará. En el transcurso de su ejecución, podría devolver un objeto que no haya sido tocado por ninguno de estos métodos. Tomemos, por ejemplo, este enfoque para el patrón de singleton:

class Meta_2(type):
    singletons = {}

    def __call__(cls, *args, **kwargs):
        if cls in Meta_2.singletons:
            # we return the only instance and skip a call to __new__()
            # and __init__()
            print ("{} singleton returning from Meta_2.__call__(), "
                   "skipping creation of new instance.".format(cls))
            return Meta_2.singletons[cls]

        # else if the singleton isn't present we proceed as usual
        print "Meta_2.__call__() before creating an instance."
        instance = super(Meta_2, cls).__call__(*args, **kwargs)
        Meta_2.singletons[cls] = instance
        print "Meta_2.__call__() returning new instance."
        return instance

class Class_2(object):

    __metaclass__ = Meta_2

    def __new__(cls, *args, **kwargs):
        print "Class_2.__new__() before creating instance."
        instance = super(Class_2, cls).__new__(cls)
        print "Class_2.__new__() returning instance."
        return instance

    def __init__(self, *args, **kwargs):
        print "entering Class_2.__init__() for initialization."
        super(Class_2, self).__init__()
        print "exiting Class_2.__init__()."

Observemos qué sucede cuando intentamos crear un objeto de tipo repetidamente. Class_2

a = Class_2()
# Meta_2.__call__() before creating an instance.
# Class_2.__new__() before creating instance.
# Class_2.__new__() returning instance.
# entering Class_2.__init__() for initialization.
# exiting Class_2.__init__().
# Meta_2.__call__() returning new instance.

b = Class_2()
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.

c = Class_2()
# <class '__main__.Class_2'> singleton returning from Meta_2.__call__(), skipping creation of new instance.

a is b is c # True




python file file-handling