En este tutorial, aprenderá a descargar archivos de la web utilizando diferentes módulos de Python. Descargará archivos normales, páginas web, videos de YouTube, archivos de Google Drive, Amazon S3 y otras fuentes.

Además, aprenderá cómo superar muchos desafíos que puede contrarrestar, como la descarga de archivos que redireccionan, la descarga de archivos grandes, la descarga multiproceso y otras tácticas.

Usando solicitudes

Puede descargar archivos desde una URL utilizando el módulo de solicitudes.

Considere el siguiente código:

1
2
3
4
5
6
7
import requests
 
 
myfile = requests.get(url)
 
open('c:/users/LikeGeeks/downloads/PythonImage.png', 'wb').write(myfile.content)

Simplemente, obtenga la URL usando el método get del módulo de solicitudes y almacene el resultado en una variable llamada "myfile". Luego, escribe el contenido de la variable en un archivo.

Usando wget

También puede descargar un archivo desde una URL utilizando el módulo wget de Python. El módulo wget se puede instalar usando pip de la siguiente manera:

pip instalar wget

Considere el siguiente código en el que descargaremos la imagen del logo de Python:

1
2
3
4
5
import wget
 
 
wget.download(url, 'c:/users/LikeGeeks/downloads/pythonLogo.png')

En este código, la URL junto con la ruta (donde se almacenará la imagen) se pasa al método de descarga del módulo wget.

Descargar archivo que redirecciona

En esta sección, aprenderá a descargar desde una URL que redirige a otra URL con un archivo .pdf mediante solicitudes. La URL es como la siguiente:

https://readthedocs.org/projects/python-guide/downloads/pdf/latest/

Para descargar este archivo pdf, use el siguiente código:

1
2
3
4
5
6
7
import requests
 
 
myfile = requests.get(url, allow_redirects=True)
 
open('c:/users/LikeGeeks/documents/hello.pdf', 'wb').write(myfile.content)

En este código, el primer paso especificamos la URL. Luego usamos el método get del módulo de solicitudes para obtener la URL. En el método get, establecemos allow_redirects en True, lo que permitirá la redirección en la URL y el contenido después de la redirección se asignará a la variable myfile.

Finalmente, abrimos un archivo para escribir el contenido obtenido.

Descargar archivos grandes en trozos

Considere que el código falló:

01
02
03
04
05
06
07
08
09
10
11
12
13
import requests
 
url = 'https://www.cs.uky.edu/~keen/115/Haltermanpythonbook.pdf'
 
r = requests.get(url, stream = True)
 
with open("PythonBook.pdf", "wb") as Pypdf:
 
    for chunk in r.iter_content(chunk_size = 1024):
 
        if chunk:
 
            Pypdf.write(chunk)

Primero, usamos el método get del módulo de solicitudes como lo hicimos antes, pero esta vez estableceremos el atributo de flujo en True.

Luego creamos un archivo llamado PythonBook.pdf en el directorio de trabajo actual y lo abrimos para escribir.

Luego especificamos el tamaño del fragmento que queremos descargar a la vez. Lo hemos establecido en 1024 bytes. Repita cada fragmento y escriba los fragmentos en el archivo hasta que terminen los fragmentos.

El shell de Python se verá así cuando se descarguen los fragmentos:

Módulos de Python

¿No es bonito? No se preocupe, le mostraremos una barra de progreso para el proceso de descarga más adelante.

Descargar varios archivos (descarga paralela / masiva)

Para descargar varios archivos a la vez, importe los siguientes módulos:

1
2
3
4
5
6
7
import os
 
import requests
 
from time import time
 
from multiprocessing.pool import ThreadPool

Importamos los módulos de tiempo y sistema operativo para comprobar cuánto tiempo lleva descargar archivos. El módulo ThreadPool le permite ejecutar múltiples subprocesos o procesos utilizando el grupo.

Creemos una función simple que envíe la respuesta a un archivo en trozos:

01
02
03
04
05
06
07
08
09
10
11
def url_response(url):
 
    path, url = url
 
    r = requests.get(url, stream = True)
 
    with open(path, 'wb') as f:
 
        for ch in r:
 
            f.write(ch)

Las URL son una matriz bidimensional que especifica la ruta y la URL de una página que desea descargar.

Pase la URL a request.get como hicimos en la sección anterior. Finalmente, abra el archivo (ruta especificada en la URL) y escriba el contenido de la página.

Ahora podemos llamar a esta función para cada URL por separado y también podemos llamar a esta función para todas las URL al mismo tiempo. Hagámoslo para cada URL por separado en el bucle for y observemos el temporizador:

1
2
3
4
5
6
7
start = time()
 
for x in urls:
 
    url_response (x)
 
print(f"Time to download: {time() - start}")

El resultado será así:

Módulos de Python

Ahora reemplace el bucle for con la siguiente línea de código:

ThreadPool (9) .imap_unordered (url_response, urls)

Ejecute el script:

Módulos de Python

Descarga con una barra de progreso

La barra de progreso es un widget de interfaz de usuario del módulo clint. Para instalar el módulo clint, escriba el siguiente comando:

pip instalar clint

Módulos de Python

Considere el siguiente código:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
import requests
 
from clint.textui import progress
 
 
r = requests.get(url, stream=True)
 
with open("LearnPython.pdf", "wb") as Pypdf:
 
    total_length = int(r.headers.get('content-length'))
 
    for ch in progress.bar(r.iter_content(chunk_size = 2391975), expected_size=(total_length/1024) + 1):
 
        if ch:
 
            Pypdf.write(ch)

En este código, importamos el módulo de solicitudes y luego de clint.textui importamos el widget de progreso. La única diferencia está en el bucle for. Usamos el método de barra del módulo de progreso mientras escribíamos el contenido en el archivo. La salida será como la siguiente:

Módulos de Python

Descarga una página web usando urllib

En esta sección, descargaremos una página web utilizando urllib.

La biblioteca urllib es una biblioteca estándar de Python, por lo que no es necesario instalarla.

La siguiente línea de código puede descargar fácilmente una página web:

urllib.request.urlretrieve ('url', 'ruta')

Especifique aquí la URL que desea guardar y dónde desea almacenarla:

urllib.request.urlretrieve ('https://www.python.org/', 'c: /users/LikeGeeks/documents/PythonOrganization.html')

En este código, usamos el método urlretrieve y pasamos la URL de un archivo junto con la ruta donde guardaremos el archivo. La extensión del archivo será .html.

Descarga a través de proxy

Si necesita usar un proxy para descargar sus archivos, puede usar el ProxyHandler del módulo urllib. Verifique el siguiente código:

1
2
3
4
5
6
7
import urllib.request
 
>>> myProxy = urllib.request.ProxyHandler({'http': '127.0.0.2'})
 
>>> openProxy = urllib.request.build_opener(myProxy)
 
>>> urllib.request.urlretrieve('https://www.python.org/')

En este código, creamos el objeto proxy y abrimos el proxy invocando el método build_opener de urllib y pasamos el objeto proxy. Luego hicimos la solicitud para recuperar la página.

Módulos de Python

Además, puede utilizar el módulo de solicitudes como se documenta en la documentación oficial:

1
2
3
4
5
import requests
 
myProxy = { 'http': 'http://127.0.0.2:3001' }
 
requests.get("https://www.python.org/", proxies=myProxy)

Simplemente importe el módulo de solicitudes y cree su objeto proxy. Entonces puedes recuperar el archivo.

Módulos de Python

Usando urllib3

El urllib3 es una versión mejorada del módulo urllib. Puedes descargarlo e instalarlo usando pip:

pip instalar urllib3

Buscaremos una página web y la almacenaremos en un archivo de texto usando urllib3.

Importe los siguientes módulos:

importar urllib3, shutil

El módulo shutil se usa cuando se trabaja con archivos.

Ahora inicialice la variable de cadena de URL así:

url = 'https://www.python.org/'

Luego usamos el PoolManager de urllib3 que realiza un seguimiento de los grupos de conexiones necesarios.

c = urllib3.PoolManager ()

Crea un archivo:

nombre de archivo = "prueba.txt"

Finalmente, enviamos una solicitud GET para buscar la URL y abrir un archivo y escribir la respuesta en ese archivo:

1
2
3
with c.request('GET', url, preload_content=False) as res, open(filename, 'wb') as out_file:
 
    shutil.copyfileobj(res, out_file)

Descargar desde Google Drive

Puede usar googledrivedownloader para descargar cualquier archivo de Google Drive. Para instalarlo, use el siguiente comando:

pip instalar googledrivedownloader

Mira el código a continuación:

1
2
3
4
5
from google_drive_downloader import GoogleDriveDownloader as gd
 
gd.download_file_from_google_drive(file_id='0B7XV2PwnZyfNalJ6cFd6dXBrckE',
 
dest_path='./data/2ndHalfJava.zip', unzip=True)

Aquí pasamos la identificación del archivo del archivo de la unidad de Google junto con la ruta de destino donde guardaremos el archivo. Luego tenemos el parámetro descomprimir. Si es Verdadero, el archivo descargado se descomprimirá en la misma carpeta de destino.

Módulos de Python

En este ejemplo, descargamos la carpeta zip y luego la carpeta se descomprime.

Descarga el archivo de S3 usando boto3

Para descargar archivos de Amazon S3, puede utilizar el módulo boto3 de Python.

Antes de comenzar, debe instalar el módulo awscli usando pip:

pip instalar awscli

Módulos de Python

Para la configuración de AWS, ejecute el siguiente comando:

aws configure

Ahora ingrese sus datos como:

1
2
3
4
5
6
7
AWS Access Key ID [None]: (The access key)
 
AWS Secret Access Key [None]: (Secret access key)
 
Default region name [None]: (Region)
 
Default output format [None]: (Json)
Módulos de Python

Para descargar un archivo de Amazon S3, importe boto3 y botocore. Boto3 es un SDK de Amazon para Python para acceder a servicios web de Amazon como S3. Botocore proporciona los servicios de línea de comandos para interactuar con los servicios web de Amazon.

Botocore viene con awscli. Para instalar boto3, ejecute lo siguiente:

pip instalar boto3

Módulos de Python

Ahora importe estos dos módulos:

importar boto3, botocore

Al descargar archivos de Amazon, necesitamos tres parámetros:

  1. El nombre de Bucket
  2. El nombre del archivo que necesita descargar
  3. El nombre del archivo después de que se haya descargado

Inicializa las variables:

1
2
3
4
5
bucket = "bucketName"
 
file_name = "filename"
 
downloaded_file = "downloadedfilename"

Ahora inicialice una variable para usar el recurso de una sesión. Para esto, llamaremos al método resource () de boto3 y pasaremos el servicio que es s3:

servicio = boto3.resource ('s3')

Finalmente, descargue el archivo usando el método download_file y pase las variables:

service.Bucket (depósito) .download_file (nombre_archivo, archivo_descargado)

Descargar videos de Youtube

Para descargar videos de YouTube, puede usar el módulo pytube.

Primero, instale el módulo pytube usando pip como:

pip instalar pytube

Módulos de Python

Ahora, importe YouTube desde pytube como:

desde pytube importar YouTube

Luego, pase la URL del video que necesita descargar:

YouTube ('https://www.youtube.com/watch?v=himEMfYQJ1w') .streams.first () .download ()

En esta línea de código, pasamos la URL. Luego están las transmisiones (lista de formatos) que tiene el video. Por ejemplo:

1
2
3
4
5
streams = yt.streams.all()
 
>>> for x in streams:
 
    print(x)

Esto imprimirá todos los formatos junto con la resolución de video de la siguiente manera:

01
02
03
04
05
06
07
08
09
10
11
<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">
<Stream: itag="43" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp8.0" acodec="vorbis">
<Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">
<Stream: itag="36" mime_type="video/3gpp" res="240p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">
<Stream: itag="17" mime_type="video/3gpp" res="144p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">
<Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">
<Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d4014">
<Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">
<Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d400c">
<Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400b">
<Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">

El primer método () toma el primer formato y el método download () descarga el video.

Si desea obtener información sobre un video, por ejemplo, el título, use .title de la siguiente manera:

1
2
3
4
5
>>> video = YouTube('https://www.youtube.com/watch?v=himEMfYQJ1w')
 
>>> video.title
 
'Linux Environment Variables'

Usando asyncio

El módulo asyncio se centra en el manejo de eventos del sistema. Funciona alrededor de un bucle de eventos que espera a que ocurra un evento y luego reacciona a ese evento. La reacción puede estar llamando a otra función. Este proceso se llama manipulación uniforme. El módulo asyncio usa corrutinas para el manejo de eventos.

Para usar el manejo de eventos de asyncio y la funcionalidad de corrutina, importaremos el módulo asyncio:

importar asyncio

Ahora defina el método asyncio coroutine así:

1
2
3
async def coroutine():
 
    await my_func()

La palabra clave async indica que esta es una corrutina nativa de asyncio. Dentro del cuerpo de la corrutina, tenemos la palabra clave await que devuelve un cierto valor. También se puede utilizar la palabra clave return.

Ahora creemos un código usando una corrutina para descargar un archivo de la web:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
>>> import os
 
>>> import urllib.request
 
>>> async def coroutine(url):
 
    r = urllib.request.urlopen(url)
 
    filename = "couroutine_downloads.txt"
 
    with open(filename, 'wb') as f:
 
        for ch in r:
 
            f.write(ch)
 
    print_msg = 'Successfully Downloaded'
 
    return print_msg
 
>>> async def main_func(urls_to_download):
 
    co = [coroutine(url) for url in urls_to_download]