Das deutsche Python-Forum

Code: Alles auswählen

import lxml.html
import requests
r=requests.get("http://www.amazon.de/...")
test=lxml.html.fromstring(r.text)
link = test.cssselect('html body div div div div div div div div h3.newaps div a')
for i in range(0,len(link)):
    print (lxml.html.tostring(link[i]))

Code: Alles auswählen

b'<a href="http://www.amazon.de/Greatest-Hits-So-Far-Explicit/dp/artist-redirect/B00F4122W4">P!nk</a>'

Code: Alles auswählen

link[i].get("href")

Code: Alles auswählen

lxml.html.tostring(link[i], method="text", encoding="utf-8")

Code: Alles auswählen

print(link[23])
print(lxml.html.tostring(link[23], method="text", encoding="utf-8"))
print((link[23].get("href")))
print(lxml.html.tostring(link[23], encoding="utf-8"))
print(lxml.html.tostring(link[23], method="text"))

Code: Alles auswählen

<Element a at 0x7ff8bef618b8>
b'F\xc3\xbcnf Freunde'
b'<a href="http://www.amazon.de/108-die-Entf%C3%BChrung-im-Skigebiet/dp/artist-redirect/B00MBJ4K5Y">F\xc3\xbcnf Freunde</a>'
http://www.amazon.de/108-die-Entf%C3%BChrung-im-Skigebiet/dp/artist-redirect/B00MBJ4K5Y
Traceback (most recent call last):
  File "/home/evd/Schreibtisch/python/Amazon/a.py", line 21, in <module>
    print(lxml.html.tostring(link[23], method="text"))
  File "/usr/lib/python3/dist-packages/lxml/html/__init__.py", line 1621, in tostring
    doctype=doctype)
  File "lxml.etree.pyx", line 3157, in lxml.etree.tostring (src/lxml/lxml.etree.c:69331)
  File "serializer.pxi", line 99, in lxml.etree._tostring (src/lxml/lxml.etree.c:114033)
  File "serializer.pxi", line 71, in lxml.etree._textToString (src/lxml/lxml.etree.c:113825)
UnicodeEncodeError: 'ascii' codec can't encode character '\xfc' in position 1: ordinal not in range(128)

Code: Alles auswählen

self.r=requests.get("http://www.amazon.de")

Code: Alles auswählen

requests.exceptions.ConnectionError: HTTPConnectionPool(host='www.amazon.de', port=80): Max retries exceeded with url: "....." (Caused by <class 'socket.gaierror'>: [Errno -2] Name or service not known)

Code: Alles auswählen

import threading, queue, lxml.html, requests

#Thread welches die Seiten in Amazon herunterlädt (queue1=1-400 welches den Link vervollständigt, queue2=die Seite)
class suchen():
    def __init__(self, queue1, queue2):
        self.queue1=queue1
        self.queue2=queue2
        self.sucher()
        
    def sucher(self):
        while  True:
            self.i = self.queue1.get()
            if self.i is None:
                self.queue1.task_done()
                break
            else:
                try:
                    self.r=requests.get("http://www.amazon.de/s/ref=sr_pg_"+str(self.i)+"?rh=n%3A77195031%2Cp_36%3A200-499%2Cp_n_format_browse-bin%3A180848031&page="+str(self.i)+"&bbn=77195031&ie=UTF8&qid=1395167727", timeout=60)
                    self.queue2.put(self.r)
                    print(self.i)
                except:
                    print("-")
                self.queue1.task_done()
            

queue1=queue.Queue(500)
queue2=queue.Queue(500)
knuenztlerliste=[]
albumnamenliste=[]
linkalbumliste=[]
bildalbumliste=[]
preisalbumliste=[]
anzahlderrunden=400        #wie viele Seiten ich durchsuchen will
anzahlderthreads=5          #wie viele threads ich dafür starten will (5 weil ich da hoffe nicht so schnell gesperrt zu werden
for n in range (1,anzahlderrunden + anzahlderthreads+1):
    if n > anzahlderrunden:
        queue1.put(None)
    else:
        queue1.put(n)
for s in range (anzahlderthreads):
    threading.Thread(target=suchen, args=(queue1,queue2)).start()
queue1.join()

#hier werden die Seiten durchsucht, nach den Werten die ich haben will
for anzahl in range (queue2.qsize()):
    print(anzahl)
    r=queue2.get()
    test=lxml.html.fromstring(r.text)
    link = test.cssselect('h3.newaps div a')
    n = 0
    for element in link:
#weil in 'schauen1' bei zu langen namen "..." am ende steht
        schauen1=len((element.text))
        try:
            schauen2=len((link[n].get("title")))
        except:
            schauen2=0
        if schauen2>schauen1:
            knuenztlerliste.append((link[n].get("title")))
        else:
            knuenztlerliste.append(element.text)
        n=n+1
    link = test.cssselect('div div h3.newaps a')
    n=0
    for element in link:
        Fehlerbehebung1=n%2          #weil 2 "href" hintereinander sind (ich will nur den ersten)
        if Fehlerbehebung1==0:
            linkalbumliste.append(link[n].get("href"))
        n=n+1
    link = test.cssselect('div h3.newaps a span.lrg.bold')
    n=0
    for element in link:
        schauen1=len((element.text))
        try:
            schauen2=len((link[n].get("title")))
        except:
            schauen2=0
        if schauen2>schauen1:
            albumnamenliste.append(link[n].get("title"))
        else:
            albumnamenliste.append((element.text)) 
        n=n+1
    link = test.cssselect('a div.imageBox img.productImage.cfMarker')
    n=0
    for element in link:
            
        bildalbumliste.append(link[n].get("src"))
        n=n+1
    link = test.cssselect('span.a-button.a-button-primary.MusicCartBuyButton span.a-button-inner a.a-button-text')
    n=0
    for element in link:   
        a=(element.text)    
        preisalbumliste.append(a[21:len(a)])
        n=n+1

#Ausgabe der Werte (im Hauptprogramm wird dies dann anders realisiert)       
print(len(preisalbumliste))
print(len(bildalbumliste))
print(len(linkalbumliste))
print(len(albumnamenliste))
print(len(knuenztlerliste))
print("Es sollten",anzahlderrunden*24,"sein")

Code: Alles auswählen

wert: 1
wert: 2
benutze wert: 2
wert: 3
benutze wert: 3
wert: 4
benutze wert: 4
wert: 5
benutze wert: 5
wert: None
Ende
benutze wert: None
wert: None
Ende

Code: Alles auswählen

"""
in den 3 Dreidimensionalen Feld ist die erste ebene die Seite (1,2,3,...). 
die Zweite Ebene die Unterteilung (kuenztler,albumname,link,bild,preis)
die Dritte Ebene ist für die exakten Daten freigegeben
"""


import threading, queue, lxml.html, requests
class sucher():
    """
    Diese Klasse sucht auf den Seiten von Amazon nach den Künstlern, Preisen, Alben ... und gibt dieser in
    gegebener Reihenfolge in einem Feld "Scanresultat" wieder.
    """
    def __init__(self):
        self.threadinput=queue.Queue(500)
        self.threadoutput=queue.Queue(500)
        self.zulange=0
        self.n = 0
        self.Scanresultat=[]
        self.Fehler=[]
        self.r=[]
        self.banzahl1=0
        self.banzahl2=0
        self.banzahl3=0
        self.banzahl4=0
        self.banzahl5=0
        for self.i in range (0,400):
            self.Scanresultat.append([])
            for self.n in range (5):
                self.Scanresultat[self.i].append([])
    
    #Dies sind die Threads die gestartet werden sollen, und welche dann die Seite herunter laden
    # 2)
    # 3)
    def suchen(self, threadinput, threadoutput):
        self.athreadinput=threadinput
        self.athreadoutput=threadoutput
        while  True:
            self.r=[]
            self.i = self.athreadinput.get()
            print("wert:",self.i)
            if self.i == None:
                self.athreadinput.task_done()
                print("Ende")
                break
            else:
                try:
                    #als erstes kommt die Seite, und dann die Seiten Nr. um es bei Buggs besser zu unterscheiden und um die Ordnung aufrecht zu erhalten
                    self.r.append(requests.get("http://www.amazon.de/s/ref=sr_pg_"+str(self.i)+"?rh=n%3A77195031%2Cp_36%3A200-499%2Cp_n_format_browse-bin%3A180848031&page="+str(self.i)+"&bbn=77195031&ie=UTF8&qid=1395167727", timeout=60))
                    self.r.append(self.i)
                    self.athreadoutput.put(self.r)
                    print("benutze wert:",self.i)
                except:
                    #wenn die Seite nicht heruntergeladen werden kann 
                    print("-",self.i)
                    self.r.append("-")
                    self.r.append(self.i)
                    self.athreadoutput.put(self.r)
                    
                self.athreadinput.task_done()
    
    #Ruft die Threads auf und setzt die werte für die queue
    def aufrufen (self,anzahl,threads):
        self.anzahlderrunden=anzahl
        self.anzahlderthreads=threads
        for self.n in range (1,self.anzahlderrunden + self.anzahlderthreads+1):
            if self.n > self.anzahlderrunden:
                self.threadinput.put(None)
            else:
                self.threadinput.put(self.n)
        for self.s in range (self.anzahlderthreads):
            threading.Thread(target=self.suchen, args=(self.threadinput,self.threadoutput)).start()
        self.threadinput.join()
        self.auswerten()
        
    #Liest die werte aus, und Speichert die Ergebnisse in ein Feld, Sortierung siehe anfangs-Kommentar     
    def auswerten(self):
        for self.anzahl in range (self.anzahlderrunden):
            self.r=self.threadoutput.get()
            self.test=lxml.html.fromstring(self.r[0].text)
            self.links = self.test.cssselect('h3.newaps div a')
            for element in self.links:
                self.schauen1=len(element.text)
                #wenn der Name zu lang ist wird er durch ein "..." am ende ersetzt, hier wird geschaut ob das der Fall ist
                try:
                    self.schauen2=len((element.get("title")))
                except:
                    self.schauen2=0
                if self.schauen2>self.schauen1:
                    self.Scanresultat[self.r[1]][0].append(element.get("title"))
                else:
                    self.Scanresultat[self.r[1]][0].append(element.text)
            self.links = self.test.cssselect('div div h3.newaps a')
            self.n=0
            for element in self.links:
                #Hier muss ich n benutzen, denn ich brauche nur jedes 2. Suchergebnis... und dies erschien mir als die einfachste und schlichteste Möglichkeit
                self.Fehlerbehebung1=self.n%2
                if self.Fehlerbehebung1==0:
                    self.Scanresultat[self.r[1]][2].append(element.get("href"))
                self.n=self.n+1
            self.links = self.test.cssselect('div h3.newaps a span.lrg.bold')
            for element in self.links:
                #wenn der Name zu lang ist wird er durch ein "..." am ende ersetzt, hier wird geschaut ob das der Fall ist
                self.schauen1=len(element.text)
                try:
                    self.schauen2=len(element.get("title"))
                except:
                    self.schauen2=0
                if self.schauen2>self.schauen1:
                    self.Scanresultat[self.r[1]][1].append(element.get("title"))
                else:
                    self.Scanresultat[self.r[1]][1].append(element.text)
            self.links = self.test.cssselect('div.imageBox img.productImage.cfMarker') # 1)
            for element in self.links:
                self.Scanresultat[self.r[1]][3].append(element.get("src"))
            self.links = self.test.cssselect('a.a-button-text')
            self.n=0
            for element in self.links:
                #Ich benötige den "n" Zähler, denn es gibt auch noch Ergebnisse die mich nicht interessieren (elemente > als 24)
                if self.n<24:
                    self.a=(element.text)    
                    self.Scanresultat[self.r[1]][4].append(self.a[21:len(self.a)])
                    self.n=self.n+1
        print(self.Scanresultat)

asucher=sucher()
asucher.aufrufen(5,2)

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf8
from __future__ import absolute_import, division, print_function
import json
import logging

import requests
from concurrent.futures import ThreadPoolExecutor
from lxml import html

logging.basicConfig()
LOG = logging.getLogger('main')
LOG.setLevel(logging.INFO)

RESULT_URL_TEMPLATE = (
    'http://www.amazon.de/s/ref=sr_pg_{0}'
        '?rh=n%3A77195031%2Cp_36%3A200-499%2Cp_n_format_browse-bin%3A180848031'
        '&page={0}'
        '&bbn=77195031'
        '&ie=UTF8'
        '&qid=1395167727'
)


def parse_product(node):
    title_node, artist_node = node.cssselect('h3 a')
    title_span = title_node.find('span')
    buy_button_nodes = node.cssselect('.MusicCartBuyButton a')
    product_image_nodes = node.cssselect('img.productImage')
    if not product_image_nodes:
        product_image_nodes = node.cssselect('img.placeholder')
    return {
        'image_url': product_image_nodes[0].get('src'),
        'url': title_node.get('href'),
        'title': title_span.get('title') or title_span.text,
        'artist': artist_node.text,
        'price': float(
            buy_button_nodes[0].text.rpartition(' ')[2] .replace(',', '.')
        ) if buy_button_nodes else None,
    }


def load_products(url):
    result = {'source': url, 'error': None, 'products': list()}
    response = requests.get(url)
    if response.ok:
        result['products'] = map(
            parse_product,
            html.fromstring(response.content)
                .get_element_by_id('resultsCol')
                .cssselect('div.prod')
        )
    else:
        result['error'] = {
            'status_code': response.status_code,
            'reason': response.reason,
        }
    return result


def load_page(number):
    LOG.info('loading page %d', number)
    result = load_products(RESULT_URL_TEMPLATE.format(number))
    result['page'] = number
    return result


def load_pages(max_workers, max_pages):
    executor = ThreadPoolExecutor(max_workers)
    futures = [
        (i, executor.submit(load_page, i)) for i in xrange(1, max_pages + 1)
    ]
    pages = list()
    for i, future in futures:
        try:
            page = future.result()
        except Exception as error:
            page = {
                'error': str(error),
                'page': i,
            }
        pages.append(page)
    return {
        'pages': pages,
    }


def main():
    pages = load_pages(5, 20)
    print(json.dumps(pages, indent=2))


if __name__ == '__main__':
    main()

Code: Alles auswählen

        self.links = self.seite.cssselect('div.imageBox img.productImage.cfMarker')
        for element in self.links:
            self.r[4].append(element.get("src")

Code: Alles auswählen

        self.links = self.seite.cssselect('a.a-button-text')
        self.n=0
        for element in self.links:
            if self.n<24:    
                self.r[2].append(element.text[21:len(element.text)])
                self.n=self.n+1
# Es gibt auch noch mehr als die 24 preise, die restlichen will ich aber nicht, deswegen alsse ich n hoch zählen