# coding = utf-8 '' ' Film Reptile Douban, prise en charge de l'exploration chronologique '' ' temps d'importation demandes d'importation les importer importer re importer json importer Save_Data journalisation d'importation #Définissez le niveau de journalisation et le nom du fichier journal logging.basicConfig ( # Niveau de journal level = "ERROR", # Format de l'heure d'impression du journal datefmt = "% Y-% m-% d% H:% M:% S", # Format du contenu d'impression du journal format = '% (asctime) s% (filename) s [ligne:% (lineno) d]% (message) s', # Consigner la sortie dans un fichier filename = ("log_2010.txt"), # Mode superposition filemode = 'w' ) # Définissez l'en-tête de la demande en-têtes = { "Referer": "https://movie.douban.com/explore", "User-Agent": "Mozilla / 5.0 (Windows NT 10.0; Win64; x64) AppleWebKit / 537.36 (KHTML, comme Gecko) Chrome / 78.0.3904.108 Safari / 537.36" } # Définir l'intervalle de temps pour obtenir l'année year_dict = { "80 年代": "1980,1989", "90 年代": "1990, 1999", "2000 年代": "2000,2009", "2010 年代": "2010,2019", } # Définir le nombre de pages de films acquises à chaque génération max_page = { "80 年代": "376", "90 年代": "752", "2000 年代": "1342", "2010 年代": "2315", } def get_doubanmovie_index (time_start, idx, headers): '' ' Obtenir le contenu de la page de catégorie de film : param movie_type: catégorie de film : en-têtes de param: demande d'informations d'en-tête : return: données de la page de catégorie de film '' ' proxy global proxy = '' my_proxy = { 'http': 'http: //' + proxy, 'https': 'https: //' + proxy, } logging.error (proxy) logging.error (my_proxy) # page_idx = idx * 20 url = "https://movie.douban.com/j/new_search_subjects?" \ "sort = U & range = 0,10 & tags =% E5% 8A% A8% E6% BC% AB & start = {}" \ "& countries =% E6% 97% A5% E6% 9C% AC & year_range = {}". format (idx, time_start) essayer: logging.error (my_proxy) ret = requests.get (url, headers = headers, timeout = (2,4)) # ret.raise_for_status () #Déterminez si le code d'état dans l'en-tête HTTP est 200 sauf: print ("Erreur lors de l'obtention du film:% s contenu de la page; URL:% s"% (time_start, url)) logging.error ("Erreur lors de l'obtention du film: contenu de la page% s; url:% s"% (time_start, url)) logging.error ('') revenir "" retour ret.text def get_movie_list (données): '' ' Analyser les données de la page du film, principalement pour obtenir le nom du film et l'URL de la page des détails du film : données param: données de la page de catégorie de film : retour: nom du film et URL de la page des détails du film '' ' movie_list = [] essayer: tmp_data = json.loads (données) topics_data = tmp_data ["données"] pour i dans topics_data: movice_name = i ["title"] movie_url = i ["url"] movie_list.append ([movice_name, movie_url]) sauf: imprimer ("Impossible d'obtenir le nom du film et la page des détails du film ~") logging.error ("Impossible d'obtenir le nom du film et la page des détails du film ~") logging.error (données) si len (movie_list) == 0: logging.error (données) revenir [] return movie_list def movie_content_page (url, en-têtes): '' ' Obtenir le contenu de la page des détails du film : param url: URL de la page de détail du film : en-têtes de param: en-têtes de demande : retour: données de la page de détail du film '' ' proxy global my_proxy = { 'http': 'http: //' + proxy, 'https': 'https: //' + proxy, } logging.error (proxy) logging.error (my_proxy) essayer: logging.error (my_proxy) ret = requests.get (url, headers = headers, timeout = (2,4)) # ret.raise_for_status () sauf: # proxy = MyProxy.get_proxy () print ("Impossible d'obtenir la page des détails du film, URL:% s"% URL) logging.error ("Impossible d'obtenir la page des détails du film, URL:% s"% URL) logging.error ('') revenir "" retour ret.text def handle_movie_data (données): '' ' Analyser les données de la page de détail du film, extraire la liste des acteurs, introduction du tracé : param data: toutes les données de la page de détail du film : retour: distribution de film : retour: Introduction à l'intrigue du film '' ' movie_info = [] mark_pattern = re.compile ('property = \ "v: average \"> (. *?) </strong>') mark_and_count = re.findall (mark_pattern, data) count_pattern = re.compile ('property = \ "v: votes \"> (. *?) </span>') count = re.findall (count_pattern, data) movie_year_pattern = re.compile ('\ "datePublished \". *?:. *? \ "(. *?) \"') movie_name_pattern = re.compile ('property = \ "v: itemreviewed \"> (. *?) </span>') movie_name = re.findall (movie_name_pattern, data) movie_year_bk = re.findall ('class = \ "year \"> (. *?) </span>', données) movie_year = re.findall (movie_year_pattern, data) essayer: #Nom du film _name = (movie_name [0]) sauf: _name = "" essayer: # Année du film _year_bk = (str (movie_year_bk [0]). replace ("(", ""). replace (")", "")) sauf: _year_bk = "" essayer: _year = (movie_year [0]) sauf: _year = "" essayer: _count = (count [0]) sauf: _count = "" essayer: _mark = (mark_and_count [0]) sauf: _mark = "" essayer: movie_info.append ([_ name, _year_bk, _year, _mark, _count]) sauf: imprimer ("err") logging.error ("ERROR movie_name:% s movie_year:% s movie_mark:% s movie_count:% s"% ( nom_film, movie_year_bk, movie_year, mark_and_count, compter)) return movie_info def main (year_type, count): proxy global my_count = 1 mk_path = 'Ensemble de données' + "\\" + type_année # Si le dossier de catégorie n'existe pas, créez-le sinon os.path.exists (mk_path): os.makedirs (mk_path) # Extraire l'année de début time_start = year_dict.get (year_type) pour idx dans la plage (nombre): page_idx = idx * 20 si page_idx> int (max_page.get (year_type)): Pause pour i dans la plage (5): # Obtenez le contenu de la page d'accueil du film dans cette catégorie index_data = get_doubanmovie_index (time_start, page_idx, headers) # Analyser le contenu de la page d'accueil, obtenir ["nom du film", "URL de la page des détails du film"] movie_url_list = get_movie_list (index_data) si len (index_data)> 0 et len (movie_url_list)> 0: Pause autre: logging.error ("------------% s"% proxy) time.sleep (2) si i> 3: Pause logging.error ("La page% d a réussi! length_html:% d"% ( (page_idx + 1), len (index_data) ) ) pour url_list dans movie_url_list: logging.error (url_list) movie_url = url_list [1] pour i dans la plage (5): # Obtenez le contenu de la page des détails du film movie_content_data = movie_content_page (movie_url, en-têtes) # Obtenez le casting du film et l'introduction de l'intrigue movie_info_list = handle_movie_data (movie_content_data) si len (movie_content_data)> 0 et len (movie_info_list)> 0: print ('Vous avez déjà% d données de film'% my_count) my_count + = 1 Pause autre: logging.error ("------------% s"% proxy) si i> 3: Pause # Enregistrer l'introduction du film Save_Data.save_content (mk_path, movie_info_list) logging.error ("La page% d a réussi! url:% s"% ( (page_idx + 1), liste_url [1] ) ) si __name__ == '__main__': sinon os.path.exists ('ensemble de données'): os.mkdir ('Ensemble de données') # Définir la liste des catégories à explorer want_get_movie = ["80s", "90s", "2000s", "2010s"] # Définissez le nombre de pages explorées, 20 par page COUNT = 2315 # Parcourez la liste des catégories à explorer pour type_name dans want_get_movie: main (nom_type, COUNT) # coding = utf-8 '' ' Module de stockage de données pour enregistrer les données du film '' ' importer csv journalisation d'importation def save_actor (chemin_fichier, données): '' ' Enregistrer les informations sur l'acteur de film : param file_path: informations de chemin enregistrées : données param: informations sur l'acteur de film :revenir: '' ' file_name = file_path + "\\" + "Actor Table.csv" #Sous le dossier du nom du film, enregistrez les données dans Actor Table.csv o_file = open (nom_fichier, "w", newline = "", encoding = "utf-8-sig") f = csv.writer (o_file) pour i dans les données: f. écrivain (i) o_file.close () def save_content (chemin_fichier, données): '' ' : param file_path: informations de chemin enregistrées : données param: informations sur le film :revenir: '' ' essayer: file_name = file_path + "\\" + "Anime data.csv" f = open (nom_fichier, "a", encoding = "utf-8-sig", newline = "") c_f = csv.writer (f) pour i dans les données: c_f.writerow (i) f.close () sauf: logging.error ("Échec de l'enregistrement des données:% s"% de données)