récupérer des liens à partir de la page web à l'aide de python et de BeautifulSoup

Par souci d'exhaustivité, le BeautifulSoup 4 version, l'utilisation de l'encodage fourni par le serveur:

from bs4 import BeautifulSoup
import urllib2

resp = urllib2.urlopen("http://www.gpsbasecamp.com/national-parks")
soup = BeautifulSoup(resp, from_encoding=resp.info().getparam('charset'))

for link in soup.find_all('a', href=True):
    print link['href']

ou le Python 3 version:

from bs4 import BeautifulSoup
import urllib.request

resp = urllib.request.urlopen("http://www.gpsbasecamp.com/national-parks")
soup = BeautifulSoup(resp, from_encoding=resp.info().get_param('charset'))

for link in soup.find_all('a', href=True):
    print(link['href'])

et une version à l'aide de la demande de la bibliothèque, qui, comme l'écrit fonctionnent dans les deux Python 2 et 3:

from bs4 import BeautifulSoup
from bs4.dammit import EncodingDetector
import requests

resp = requests.get("http://www.gpsbasecamp.com/national-parks")
http_encoding = resp.encoding if 'charset' in resp.headers.get('content-type', '').lower() else None
html_encoding = EncodingDetector.find_declared_encoding(resp.content, is_html=True)
encoding = html_encoding or http_encoding
soup = BeautifulSoup(resp.content, from_encoding=encoding)

for link in soup.find_all('a', href=True):
    print(link['href'])

La soup.find_all('a', href=True) appel trouve tous <a> éléments qui ont une href attribut; éléments sans l'attribut est ignoré.

BeautifulSoup 3 développement arrêté en Mars 2012, de nouveaux projets devraient vraiment utiliser BeautifulSoup 4, toujours.

Noter que vous devez laisser le décodage du langage HTML à partir d'octets de BeautifulSoup. Vous pouvez vous informer BeautifulSoup de la characterset trouvé dans l'en-tête HTTP pour aider au décodage, mais ce peut être mauvais et est en conflit avec un <meta> en-tête infos trouvées dans le code HTML lui-même, qui est pourquoi la ci-dessus utilise la BeautifulSoup interne de la méthode de classe EncodingDetector.find_declared_encoding() pour assurer que de telles intégré de codage des astuces gagner plus d'un problème de configuration du serveur.

Avec requests, le response.encoding attribut par défaut Latin-1 si la réponse a un text/* mimetype, même si aucune characterset a été retourné. Ceci est cohérent avec le HTTP Rfc, mais douloureuse lorsqu'il est utilisé avec d'analyse HTML, de sorte que vous devez ignorer cet attribut lorsque aucune charset est défini dans l'en-tête Content-Type.

import urllib2
import BeautifulSoup

request = urllib2.Request("http://www.gpsbasecamp.com/national-parks")
response = urllib2.urlopen(request)
soup = BeautifulSoup.BeautifulSoup(response)
for a in soup.findAll('a'):
  if 'national-park' in a['href']:
    print 'found a url with national-park in the link'

Le code suivant pour récupérer tous les liens disponibles dans une page web en utilisant urllib2 et BeautifulSoup4:

import urllib2
from bs4 import BeautifulSoup

url = urllib2.urlopen("http://www.espncricinfo.com/").read()
soup = BeautifulSoup(url)

for line in soup.find_all('a'):
    print(line.get('href'))

Pour trouver tous les liens, nous allons dans cet exemple utiliser le module urllib2
avec la ré.module
*L'un des plus puissants de la fonction dans le module re est "re.findall()".
Tout en ré.recherche() est utilisé pour trouver le premier match, pour un motif, re.findall() trouve tous
les matchs et les renvoie sous la forme d'une liste de chaînes de caractères, chaque chaîne de caractères représentant un match*

import urllib2

import re
#connect to a URL
website = urllib2.urlopen(url)

#read html code
html = website.read()

#use re.findall to get all the links
links = re.findall('"((http|ftp)s?://.*?)"', html)

print links

Ce script fait ce que vous cherchez, Mais résout également les liens vers des liens absolus.

import urllib
import lxml.html
import urlparse

def get_dom(url):
    connection = urllib.urlopen(url)
    return lxml.html.fromstring(connection.read())

def get_links(url):
    return resolve_links((link for link in get_dom(url).xpath('//a/@href')))

def guess_root(links):
    for link in links:
        if link.startswith('http'):
            parsed_link = urlparse.urlparse(link)
            scheme = parsed_link.scheme + '://'
            netloc = parsed_link.netloc
            return scheme + netloc

def resolve_links(links):
    root = guess_root(links)
    for link in links:
        if not link.startswith('http'):
            link = urlparse.urljoin(root, link)
        yield link  

for link in get_links('http://www.google.com'):
    print link

Voici un exemple d'utilisation de @ars accepté de répondre et de la BeautifulSoup4, requests, et wget modules pour gérer les téléchargements.

import requests
import wget
import os

from bs4 import BeautifulSoup, SoupStrainer

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/eeg-mld/eeg_full/'
file_type = '.tar.gz'

response = requests.get(url)

for link in BeautifulSoup(response.content, 'html.parser', parse_only=SoupStrainer('a')):
    if link.has_attr('href'):
        if file_type in link['href']:
            full_path = url + link['href']
            wget.download(full_path)

BeatifulSoup propre analyseur peut être lent. Il serait peut-être plus réalisable à utiliser lxml qui est capable d'analyser directement à partir d'une URL (avec certaines limitations mentionnées ci-dessous).

import lxml.html

doc = lxml.html.parse(url)

links = doc.xpath('//a[@href]')

for link in links:
    print link.attrib['href']

Le code ci-dessus sera de retour les liens que est, et dans la plupart des cas, ils seraient liens relatifs ou absolus à partir de la racine du site. Depuis mon cas d'utilisation était de n'extraire qu'un certain type de liens, ci-dessous est une version qui convertit les liens Url et qui accepte éventuellement un glob motif comme *.mp3. Il ne gère pas les simples et le double de points dans les chemins relatifs, mais jusqu'à présent, je n'ai pas besoin d'elle. Si vous avez besoin pour analyser les URL des fragments contenant des ../ ou ./ puis urlparse.urljoin pourrait venir dans maniable.

NOTE: Direct lxml analyser les url ne gère pas le chargement de https et ne pas faire des redirections, donc, pour cette raison, la version ci-dessous est à l'aide de urllib2 + lxml.

#!/usr/bin/env python
import sys
import urllib2
import urlparse
import lxml.html
import fnmatch

try:
    import urltools as urltools
except ImportError:
    sys.stderr.write('To normalize URLs run: `pip install urltools --user`')
    urltools = None


def get_host(url):
    p = urlparse.urlparse(url)
    return "{}://{}".format(p.scheme, p.netloc)


if __name__ == '__main__':
    url = sys.argv[1]
    host = get_host(url)
    glob_patt = len(sys.argv) > 2 and sys.argv[2] or '*'

    doc = lxml.html.parse(urllib2.urlopen(url))
    links = doc.xpath('//a[@href]')

    for link in links:
        href = link.attrib['href']

        if fnmatch.fnmatch(href, glob_patt):

            if not href.startswith(('http://', 'https://' 'ftp://')):

                if href.startswith('/'):
                    href = host + href
                else:
                    parent_url = url.rsplit('/', 1)[0]
                    href = urlparse.urljoin(parent_url, href)

                    if urltools:
                        href = urltools.normalize(href)

            print href

L'utilisation est la suivante:

getlinks.py http://stackoverflow.com/a/37758066/191246
getlinks.py http://stackoverflow.com/a/37758066/191246 "*users*"
getlinks.py http://fakedomain.mu/somepage.html "*.mp3"