Tengo este bloque de código:
def get_spain_accomodations():
pool = Pool()
links = soup.find_all('a', class_="hotel_name_link url")
pool.map(get_page_links, links)
#for a in soup.find_all('a', class_="hotel_name_link url"):
# hotel_url = "https://www.booking.com" + a['href'].strip()
# hotels_url_list.append(hotel_url)
def get_page_links(link):
hotel_url = "https://www.booking.com" + link['href'].strip()
hotels_url_list.append(hotel_url)
Por alguna razón, hotel_url no se agrega a la lista. Si intento con el bucle comentado, realmente funciona, pero no con la función map (). También imprimí hotel_url para cada llamada get_page_links y funcionó. No tengo ni idea de lo que está pasando. A continuación se muestran las llamadas de función.
init_BeautifulSoup()
get_spain_accomodations()
#get_hotels_wifi_rating()
for link in hotels_url_list:
print link
El código se ejecuta sin errores pero la lista de enlaces no se imprime.
Es importante comprender que los procesos se ejecutan en áreas aisladas de la memoria. Cada proceso tendrá su propia instancia de hotels_url_listy no hay una manera (fácil) de "pegar" esos valores en la lista del proceso principal: si en el proceso principal crea una instancia de list, esa instancia no es la misma que usan los subprocesos: Cuando hace un .fork()(también conocido como crear un subproceso), la memoria del proceso padre se clona en el proceso hijo. Entonces, si el padre tenía una instancia de listen la hotels_url_listvariable, también tendrá una instancia de list(también llamada hotels_url_list) en el proceso secundario, PERO no serán iguales (ocuparán áreas diferentes en la memoria).
Esto no sucede con Threads . Comparten memoria.
Yo diría (no es que yo sea un experto aquí) que la forma canónica de comunicar procesos en este caso sería una Cola : el proceso hijo pone cosas en la cola, el proceso padre las agarra:
from multiprocessing import Process, Queue
def get_spain_accomodations():
q = Queue()
processes = []
links = ['http://foo.com', 'http://bar.com', 'http://baz.com']
hotels_url_list = []
for link in links:
p = Process(target=get_page_links, args=(link, q,))
p.start()
processes.append(p)
for p in processes:
p.join()
hotels_url_list.append(q.get())
print("Collected: %s" % hotels_url_list)
def get_page_links(link, q):
print("link==%s" % link)
hotel_url = "https://www.booking.com" + link
q.put(hotel_url)
if __name__ == "__main__":
get_spain_accomodations()
Esto genera cada enlace precedido de lo que https://www.booking.comocurre previamente en procesos independientes:
link==http://foo.com
link==http://bar.com
link==http://baz.com
Collected: ['https://www.booking.comhttp://foo.com', 'https://www.booking.comhttp://bar.com', 'https://www.booking.comhttp://baz.com']
No sé si le ayudará, pero para mí, ayuda ver la Cola como un "archivo compartido" que ambos procesos conocen. Imagina que tienes dos programas diferentes completos, y uno de ellos sabe que tiene que escribir cosas en un archivo llamado /tmp/foobar.txty el otro sabe que tiene que leer desde un archivo llamado /tmp/foobar.txt. De esa manera pueden "comunicarse" entre sí. Este párrafo es solo una "metáfora" (aunque así es como funcionan las tuberías de Unix ) ... ¿No es que las colas funcionan exactamente así, pero tal vez ayude a comprender el concepto? No sé, de verdad, tal vez lo hice más confuso ...
Otra forma sería usar Threads y recopilar su valor de retorno, como se explica aquí .
Este artículo se recopila de Internet, indique la fuente cuando se vuelva a imprimir.
En caso de infracción, por favor [email protected] Eliminar
Déjame decir algunas palabras