Baixando uma imagem via urllib e python

183

Então, estou tentando criar um script Python que faça o download de webcomics e os coloque em uma pasta na minha área de trabalho. Encontrei alguns programas semelhantes aqui que fazem algo semelhante, mas nada como o que eu preciso. O que eu achei mais parecido está aqui ( http://bytes.com/topic/python/answers/850927-problem-using-urllib-download-images ). Eu tentei usar este código:

>>> import urllib
>>> image = urllib.URLopener()
>>> image.retrieve("http://www.gunnerkrigg.com//comics/00000001.jpg","00000001.jpg")
('00000001.jpg', <httplib.HTTPMessage instance at 0x1457a80>)

Procurei no meu computador um arquivo "00000001.jpg", mas tudo o que encontrei foi a imagem em cache do mesmo. Não tenho certeza se ele salvou o arquivo no meu computador. Depois de entender como fazer o download do arquivo, acho que sei como lidar com o resto. Basicamente, basta usar um loop for e dividir a string no '00000000'. 'Jpg' e incrementar o '00000000' até o maior número, que eu precisaria determinar de alguma forma. Alguma recomendação sobre a melhor maneira de fazer isso ou como fazer o download do arquivo corretamente?

Obrigado!

EDIT 15/6/10

Aqui está o script completo, ele salva os arquivos em qualquer diretório que você escolher. Por alguma estranha razão, os arquivos não estavam sendo baixados e apenas o fizeram. Qualquer sugestão sobre como limpá-lo seria muito apreciada. Atualmente, estou descobrindo como descobrir muitas histórias em quadrinhos no site para que eu possa obter apenas a mais recente, em vez de ter o programa encerrado após um certo número de exceções.

import urllib
import os

comicCounter=len(os.listdir('/file'))+1  # reads the number of files in the folder to start downloading at the next comic
errorCount=0

def download_comic(url,comicName):
    """
    download a comic in the form of

    url = http://www.example.com
    comicName = '00000000.jpg'
    """
    image=urllib.URLopener()
    image.retrieve(url,comicName)  # download comicName at URL

while comicCounter <= 1000:  # not the most elegant solution
    os.chdir('/file')  # set where files download to
        try:
        if comicCounter < 10:  # needed to break into 10^n segments because comic names are a set of zeros followed by a number
            comicNumber=str('0000000'+str(comicCounter))  # string containing the eight digit comic number
            comicName=str(comicNumber+".jpg")  # string containing the file name
            url=str("http://www.gunnerkrigg.com//comics/"+comicName)  # creates the URL for the comic
            comicCounter+=1  # increments the comic counter to go to the next comic, must be before the download in case the download raises an exception
            download_comic(url,comicName)  # uses the function defined above to download the comic
            print url
        if 10 <= comicCounter < 100:
            comicNumber=str('000000'+str(comicCounter))
            comicName=str(comicNumber+".jpg")
            url=str("http://www.gunnerkrigg.com//comics/"+comicName)
            comicCounter+=1
            download_comic(url,comicName)
            print url
        if 100 <= comicCounter < 1000:
            comicNumber=str('00000'+str(comicCounter))
            comicName=str(comicNumber+".jpg")
            url=str("http://www.gunnerkrigg.com//comics/"+comicName)
            comicCounter+=1
            download_comic(url,comicName)
            print url
        else:  # quit the program if any number outside this range shows up
            quit
    except IOError:  # urllib raises an IOError for a 404 error, when the comic doesn't exist
        errorCount+=1  # add one to the error count
        if errorCount>3:  # if more than three errors occur during downloading, quit the program
            break
        else:
            print str("comic"+ ' ' + str(comicCounter) + ' ' + "does not exist")  # otherwise say that the certain comic number doesn't exist
print "all comics are up to date"  # prints if all comics are downloaded
Mike
fonte
Ok, eu tenho todos eles para baixar! Agora estou preso a uma solução muito deselegante para determinar quantos quadrinhos estão online ... Basicamente, estou executando o programa para um número que eu sei que está acima do número de quadrinhos e, em seguida, executando uma exceção para surgir quando uma história em quadrinhos não existe, e quando a exceção surge mais do que duas vezes (já que não acho que mais de dois quadrinhos estejam faltando), ele sai do programa, pensando que não há mais o que baixar. Como não tenho acesso ao site, existe uma maneira melhor de determinar quantos arquivos existem no site? Vou postar meu código em um segundo.
Mike
creativebe.com/icombiner/merge-jpg.html Usei esse programa para mesclar todos os arquivos .jpg em um PDF. Funciona incrível, e é grátis!
Mike
7
Considere postar sua solução como resposta e removê-la da pergunta. Mensagens de interrogação são para pedir respostas perguntas, mensagens resposta :-)
BartoszKP
por que isso está marcado beautifulsoup? Este post aparece na lista das principais beautifulsoupperguntas #
P0W 26/11
1
@ P0W Eu removi a tag discutida.
kmonsoor 28/12/19

Respostas:

252

Python 2

Usando urllib.urlretrieve

import urllib
urllib.urlretrieve("http://www.gunnerkrigg.com//comics/00000001.jpg", "00000001.jpg")

Python 3

Usando urllib.request.urlretrieve (parte da interface herdada do Python 3, funciona exatamente da mesma maneira)

import urllib.request
urllib.request.urlretrieve("http://www.gunnerkrigg.com//comics/00000001.jpg", "00000001.jpg")
Matthew Flaschen
fonte
Parece estar cortando a extensão do arquivo para mim quando passado como argumento (a extensão está presente no URL original). Alguma idéia do porquê?
precisa saber é o seguinte
1
O seu sim. Eu acho que assumi que, se nenhuma extensão do arquivo fosse fornecida, a extensão do arquivo seria anexada. Fazia sentido para mim na época, mas acho que agora entendo o que está acontecendo.
precisa saber é o seguinte
65
Nota para o Python 3, você precisaria importar [url.request] ( docs.python.org/3.0/library/… ):import urllib.request urllib.request.retrieve("http://...")
wasabigeek
1
Observe que a lista de documentos do Python 3 recupera () como parte de uma "Interface herdada" e diz que pode ser preterida no futuro.
Nathan Wailes
18
Nota para Python 3 é realmente import urllib.request urllib.request.urlretrieve("http://...jpg", "1.jpg"). Agora é a urlretrievepartir da 3.x.
user1032613
81
import urllib
f = open('00000001.jpg','wb')
f.write(urllib.urlopen('http://www.gunnerkrigg.com//comics/00000001.jpg').read())
f.close()
DiGMi
fonte
70

Apenas para o registro, usando a biblioteca de solicitações.

import requests
f = open('00000001.jpg','wb')
f.write(requests.get('http://www.gunnerkrigg.com//comics/00000001.jpg').content)
f.close()

Embora deva verificar se há erros no request.get ().

ellimilial
fonte
1
Mesmo que essa solução não esteja usando o urllib, você já deve estar usando a biblioteca de solicitações já no seu script python (esse foi o meu caso enquanto procurava por isso); portanto, convém usá-lo também para obter suas fotos.
Iam Zesh
Obrigado por postar esta resposta em cima das outras. Acabei precisando de cabeçalhos personalizados para que meu download funcionasse, e o ponteiro para a biblioteca de solicitações reduziu consideravelmente o processo de fazer com que tudo funcionasse para mim.
precisa
Não foi possível obter o urllib para trabalhar no python3. Os pedidos não tiveram problemas e já estão carregados! A escolha muito melhor eu acho.
precisa saber é o seguinte
@ user3023715 em python3, você precisa importar a solicitação do urllib veja aqui #
Yassine Sedrani
34

Para o Python 3, você precisará importar import urllib.request:

import urllib.request 

urllib.request.urlretrieve(url, filename)

para mais informações confira o link

HISI
fonte
15

Versão Python 3 da resposta de @ DiGMi:

from urllib import request
f = open('00000001.jpg', 'wb')
f.write(request.urlopen("http://www.gunnerkrigg.com/comics/00000001.jpg").read())
f.close()
Dennis Golomazov
fonte
10

Encontrei esta resposta e edito-a de maneira mais confiável

def download_photo(self, img_url, filename):
    try:
        image_on_web = urllib.urlopen(img_url)
        if image_on_web.headers.maintype == 'image':
            buf = image_on_web.read()
            path = os.getcwd() + DOWNLOADED_IMAGE_PATH
            file_path = "%s%s" % (path, filename)
            downloaded_image = file(file_path, "wb")
            downloaded_image.write(buf)
            downloaded_image.close()
            image_on_web.close()
        else:
            return False    
    except:
        return False
    return True

Com isso, você nunca obtém outros recursos ou exceções durante o download.

Janith Chinthana
fonte
1
Você deve remover o 'self'
Euphe 27/03
8

Se você souber que os arquivos estão localizados no mesmo diretório dirdo site sitee têm o seguinte formato: filename_01.jpg, ..., filename_10.jpg, faça o download de todos eles:

import requests

for x in range(1, 10):
    str1 = 'filename_%2.2d.jpg' % (x)
    str2 = 'http://site/dir/filename_%2.2d.jpg' % (x)

    f = open(str1, 'wb')
    f.write(requests.get(str2).content)
    f.close()
len
fonte
7

É mais fácil usar apenas .read()para ler a resposta parcial ou inteira e gravá-la em um arquivo que você abriu em um local conhecido.

Ignacio Vazquez-Abrams
fonte
5

Talvez você precise de 'User-Agent':

import urllib2
opener = urllib2.build_opener()
opener.addheaders = [('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.137 Safari/537.36')]
response = opener.open('http://google.com')
htmlData = response.read()
f = open('file.txt','w')
f.write(htmlData )
f.close()
Alexander
fonte
Talvez a página não esteja disponível?
Alexander
3

Além de sugerir que você leia os documentos com retrieve()atenção ( http://docs.python.org/library/urllib.html#urllib.URLopener.retrieve ), sugiro realmente chamar read()o conteúdo da resposta e salvá-lo em um arquivo de sua escolha, em vez de deixá-lo no arquivo temporário que a recuperação cria.

Gabriel Hurley
fonte
3

Todos os códigos acima não permitem preservar o nome da imagem original, o que às vezes é necessário. Isso ajudará a salvar as imagens na unidade local, preservando o nome da imagem original

    IMAGE = URL.rsplit('/',1)[1]
    urllib.urlretrieve(URL, IMAGE)

Tente isso para mais detalhes.

Ojas
fonte
3

Isso funcionou para mim usando python 3.

Ele obtém uma lista de URLs do arquivo csv e inicia o download para uma pasta. Caso o conteúdo ou a imagem não exista, é preciso essa exceção e continua fazendo sua mágica.

import urllib.request
import csv
import os

errorCount=0

file_list = "/Users/$USER/Desktop/YOUR-FILE-TO-DOWNLOAD-IMAGES/image_{0}.jpg"

# CSV file must separate by commas
# urls.csv is set to your current working directory make sure your cd into or add the corresponding path
with open ('urls.csv') as images:
    images = csv.reader(images)
    img_count = 1
    print("Please Wait.. it will take some time")
    for image in images:
        try:
            urllib.request.urlretrieve(image[0],
            file_list.format(img_count))
            img_count += 1
        except IOError:
            errorCount+=1
            # Stop in case you reach 100 errors downloading images
            if errorCount>100:
                break
            else:
                print ("File does not exist")

print ("Done!")
Vencedor
fonte
2

Uma solução mais simples pode ser (python 3):

import urllib.request
import os
os.chdir("D:\\comic") #your path
i=1;
s="00000000"
while i<1000:
    try:
        urllib.request.urlretrieve("http://www.gunnerkrigg.com//comics/"+ s[:8-len(str(i))]+ str(i)+".jpg",str(i)+".jpg")
    except:
        print("not possible" + str(i))
    i+=1;
Ayush
fonte
Cuidado ao usar um bare, exceto assim, consulte stackoverflow.com/questions/54948548/… .
AMC
1

Que tal isso:

import urllib, os

def from_url( url, filename = None ):
    '''Store the url content to filename'''
    if not filename:
        filename = os.path.basename( os.path.realpath(url) )

    req = urllib.request.Request( url )
    try:
        response = urllib.request.urlopen( req )
    except urllib.error.URLError as e:
        if hasattr( e, 'reason' ):
            print( 'Fail in reaching the server -> ', e.reason )
            return False
        elif hasattr( e, 'code' ):
            print( 'The server couldn\'t fulfill the request -> ', e.code )
            return False
    else:
        with open( filename, 'wb' ) as fo:
            fo.write( response.read() )
            print( 'Url saved as %s' % filename )
        return True

##

def main():
    test_url = 'http://cdn.sstatic.net/stackoverflow/img/favicon.ico'

    from_url( test_url )

if __name__ == '__main__':
    main()
gmas80
fonte
0

Se você precisar de suporte de proxy, poderá fazer o seguinte:

  if needProxy == False:
    returnCode, urlReturnResponse = urllib.urlretrieve( myUrl, fullJpegPathAndName )
  else:
    proxy_support = urllib2.ProxyHandler({"https":myHttpProxyAddress})
    opener = urllib2.build_opener(proxy_support)
    urllib2.install_opener(opener)
    urlReader = urllib2.urlopen( myUrl ).read() 
    with open( fullJpegPathAndName, "w" ) as f:
      f.write( urlReader )
Eamonn Kenny
fonte
0

Outra maneira de fazer isso é através da biblioteca fastai. Isso funcionou como um encanto para mim. Eu estava enfrentando um SSL: CERTIFICATE_VERIFY_FAILED Erroruso, urlretrieveentão eu tentei isso.

url = 'https://www.linkdoesntexist.com/lennon.jpg'
fastai.core.download_url(url,'image1.jpg', show_progress=False)
Sid
fonte
Eu estava enfrentando um SSL: Erro CERTIFICATE_VERIFY_FAILED stackoverflow.com/questions/27835619/…
AMC
0

Usando solicitações

import requests
import shutil,os

headers = {
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36'
}
currentDir = os.getcwd()
path = os.path.join(currentDir,'Images')#saving images to Images folder

def ImageDl(url):
    attempts = 0
    while attempts < 5:#retry 5 times
        try:
            filename = url.split('/')[-1]
            r = requests.get(url,headers=headers,stream=True,timeout=5)
            if r.status_code == 200:
                with open(os.path.join(path,filename),'wb') as f:
                    r.raw.decode_content = True
                    shutil.copyfileobj(r.raw,f)
            print(filename)
            break
        except Exception as e:
            attempts+=1
            print(e)

if __name__ == '__main__':
    ImageDl(url)
Sohan Das
fonte
0

Usando o urllib, você pode fazer isso instantaneamente.

import urllib.request

opener=urllib.request.build_opener()
opener.addheaders=[('User-Agent','Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1941.0 Safari/537.36')]
urllib.request.install_opener(opener)

urllib.request.urlretrieve(URL, "images/0.jpg")
Shenoy Sreekant
fonte