Dans ce blog, nous allons apprendre à récupérer les commentaires TikTok. Si vous souhaitez un tutoriel détaillé sur gratter TikTok données, consultez notre guide sur «Comment scraper TikTok".

En 2024, TikTok compte plus de 4 milliard de téléchargements Le réseau social est devenu l'une des plateformes de médias sociaux qui connaît la croissance la plus rapide ces derniers temps. Des personnes de tous âges, des adolescents aux jeunes adultes et même aux personnes âgées, l'utilisent, ce qui ajoute à son immense popularité et à son influence sur la culture.

Statistiques TikTok par âge et par sexe

Les commentaires sur les vidéos TikTok fournissent des informations sur l'engagement des utilisateurs, leurs sentiments, leurs tendances et bien plus encore. Les données des commentaires TikTok permettent aux chercheurs, aux spécialistes du marketing et aux passionnés de données d'approfondir les interactions des utilisateurs, d'identifier les contenus tendance et de mieux comprendre la communauté dynamique de TikTok.

Commençons donc à récupérer les commentaires TikTok dans Python.

Table des Matières

  1. Notions essentielles sur TikTok Comment Scraper
  2. Configurer l'environnement Python et installer les bibliothèques nécessaires
  3. Extraire les commentaires HTML des vidéos TikTok
  4. Extraire les commentaires TikTok au format JSON
  5. Gérer la pagination dans les commentaires TikTok Scraping
  6. Sauvegarde des données de commentaires TikTok récupérées
  7. Code complet avec pagination et sauvegarde
  8. Foire Aux Questions (FAQ)

1. Notions essentielles sur TikTok Comment Scraper

Vous devez avoir des connaissances de base du langage Python, HTML et CSS pour ce tutoriel. Deuxièmement, la configuration Crawlbase Crawling API pour récupérer les commentaires de TikTok. Tout ce que vous avez à faire est Inscription à Crawlbase et vous recevrez gratuitement 1000 demandes pour récupérer gratuitement les commentaires TikTok.

Diriger vers Documentation du compte pour obtenir votre jeton.

Documentation du compte

Dans votre tableau de bord, vous trouverez deux types de jetons. Le jeton normal est destiné aux sites Web classiques et le jeton JS est destiné aux sites Web contenant beaucoup de contenu dynamique ou JavaScript. Étant donné que TikTok utilise beaucoup de JavaScript, nous utiliserons le jeton JS.

Maintenant, pour la configuration de Python, assurez-vous que Python est installé. Vous pouvez télécharger et installer Python à partir du site officiel Site Web Python en fonction de votre système d'exploitation. De plus, assurez-vous que pip, le gestionnaire de paquets Python, est installé pour installer les bibliothèques et dépendances nécessaires.

Vous êtes maintenant bien équipé pour commencer à extraire les commentaires des vidéos TikTok à l'aide de Python et du Crawlbase Crawling API.

2. Configurer l'environnement Python et installer les bibliothèques nécessaires

Pour commencer à extraire les commentaires des vidéos TikTok, suivez ces étapes pour configurer l'environnement de votre projet :

Installation de Python:Si vous ne l'avez pas déjà fait, téléchargez et installez Python depuis le site Web officiel de Python. Assurez-vous d'ajouter Python au PATH de votre système lors de l'installation. Vous pouvez vérifier l'installation en ouvrant une invite de commande ou un terminal et en exécutant la commande suivante :

1
python --version

Si Python est correctement installé, vous verrez le numéro de version installée.

Créer un nouvel environnement Python:Il est recommandé de travailler dans un environnement virtuel pour gérer les dépendances du projet. Créez un nouvel environnement virtuel à l'aide des commandes suivantes :

1
2
3
4
5
6
7
8
# Créer un nouvel environnement virtuel
python -m venv monenv

# Activer l'environnement virtuel
# Sous Windows
myenv\Scripts\activate
# Sur macOS/Linux
source myenv/bin/activate

Installer les bibliothèques nécessaires:Installez les bibliothèques Python requises pour le scraping Web et l'extraction de données. Les bibliothèques clés incluent requests, beautifulsoup4et crawlbaseVous pouvez installer ces bibliothèques en utilisant pip, le gestionnaire de paquets Python :

1
demandes d'installation de pip beautifulsoup4 crawlbase

Initialiser les fichiers du projet: Créer un nouveau fichier de script Python tiktok_comments_scraper.py pour votre projet de scraping de commentaires TikTok. Vous pouvez utiliser n'importe quel éditeur de texte ou environnement de développement intégré (IDE) de votre choix pour écrire votre code Python.

Une fois votre environnement de projet configuré et vos bibliothèques installées, vous êtes prêt à commencer à récupérer les commentaires des vidéos TikTok. Passons à l'étape suivante.

3. Extraire les commentaires HTML des vidéos TikTok

Pour commencer à extraire les commentaires vidéo TikTok, nous devons récupérer le contenu HTML de la page TikTok où se trouvent les commentaires. Il existe deux approches courantes pour y parvenir : utiliser un bibliothèque de requêtes HTTP standard comme requests ou en utilisant le Crawlbase Crawling API..

Extraction des commentaires HTML de TikTok à l'aide d'une approche courante

Dans l’approche commune, nous utilisons des bibliothèques Python telles que requests pour récupérer le contenu HTML de la page vidéo TikTok. Voici un exemple simple de la manière dont vous pouvez y parvenir :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
importer demandes

# Fonction pour récupérer du HTML à l'aide de requêtes
def récupérer_html(url):
    Essai:
        réponse = demandes.get(url)
        if réponse.status_code == 200:
            retourner réponse.texte
        d'autre:
            impression(f"Échec de la récupération du code HTML. Code d'état : {réponse.status_code}")
            retourner Aucun
    sauf Exception as e:
        impression(f"Une erreur s'est produite : {str(e)}")
        retourner Aucun

# Exemple d'utilisation
tiktok_url = "https://www.tiktok.com/@khaby.lame/video/7255327059302419738"
html_content = récupérer_html(tiktok_url)
if contenu_html :
    impression(contenu_html)

Copiez le code ci-dessus dans votre tiktok_comments_scraper.py fichier et exécutez la commande suivante dans le répertoire où le fichier est présent.

1
python tiktok_comments_scraper.py

Vous verrez que le HTML de la page est imprimé sur le terminal.

Sortie HTML d'approche commune

Mais pourquoi n'y a-t-il aucune information utile dans le HTML ? C'est parce que TikTok s'appuie sur le rendu JavaScript pour charger les données essentielles de manière dynamique. Malheureusement, avec les méthodes de scraping conventionnelles, l'accès à ces données peut s'avérer difficile.

Limitations des approches de scraping courantes

L'approche courante consistant à récupérer du HTML à l'aide de bibliothèques telles que requests peut rencontrer des limitations lors de la récupération des commentaires vidéo TikTok. Certains des problèmes liés à cette approche incluent :

Problèmes courants liés à l'approche de scraping Web
  1. Exécution JavaScript limitée:Les requêtes HTTP standard n'exécutent pas JavaScript, ce qui signifie que le contenu chargé dynamiquement, comme les commentaires sur les vidéos TikTok, peut ne pas être capturé avec précision.
  2. Récupération de données incomplètes:Les pages TikTok chargent souvent les commentaires de manière asynchrone ou via des requêtes AJAX, qui peuvent ne pas être entièrement capturées par une seule requête HTTP. Par conséquent, le code HTML récupéré peut manquer de certains éléments ou contenir des espaces réservés au lieu de commentaires réels.
  3. Limitation de débit et blocage IP:Le scraping continu à l'aide de méthodes traditionnelles peut déclencher des limites de débit ou des mécanismes de blocage IP sur les serveurs TikTok, entraînant un accès restreint ou des interdictions temporaires.

Pour surmonter ces problèmes et garantir un scraping précis des commentaires vidéo TikTok, des méthodes alternatives telles que l'utilisation navigateurs sans tête or API de rendu dynamique peut être nécessaire. L'une des API disponibles est Crawlbase Crawling API.

Extraction de HTML à l'aide de Crawlbase Crawling API

Pour surmonter les limites de l'approche commune et récupérer efficacement les commentaires HTML des vidéos TikTok, nous pouvons utiliser le Crawlbase Crawling API. Cette API nous permet de récupérer le contenu HTML rendu des pages TikTok, y compris contenu chargé dynamiquement.

Voici comment vous pouvez utiliser le Crawlbase Crawling API pour récupérer les commentaires HTML des vidéos TikTok :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
à partir de base d'exploration importer API d'exploration

# Initialiser le Crawlbase Objet CrawlingAPI
crawling_api = API d'exploration({"jeton": "CRAWLBASE_JS_TOKEN"})

choix = {
    'ajax_wait': 'vrai',
    'page_wait': 10000,
    "user_agent": "Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64) AppleWebKit/537.36 (KHTML, comme Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0"
}

# Fonction pour récupérer du HTML en utilisant Crawlbase Crawling API
def récupérer_html_crawlbase(url):
    de défis crawling_api, options
    Essai:
        réponse = crawling_api.get(url, options)
        if réponse['en-têtes']['pc_status']== «200 ':
            retourner réponse['corps'].décoder(« utf-8 »)
        d'autre:
            impression(f"Échec de la récupération du code HTML. Crawlbase code d'état : {réponse['en-têtes']['pc_status']}")
            retourner Aucun
    sauf Exception as e:
        impression(f"Une erreur s'est produite : {str(e)}")
        retourner Aucun

# Exemple d'utilisation
tiktok_url = "https://www.tiktok.com/@khaby.lame/video/7255327059302419738"
html_content = fetch_html_crawlbase(tiktok_url)
if contenu_html :
    impression(contenu_html)

Le Crawlbase Crawling API nous permet de récupérer efficacement le contenu HTML des pages TikTok, en garantissant que le contenu rendu par JavaScript est capturé avec précision. Cette approche est particulièrement utile pour récupérer du contenu dynamique comme les commentaires vidéo TikTok.

Crawling API Sortie HTML

4. Extraire les commentaires TikTok au format JSON

L'extraction des commentaires TikTok implique l'extraction de divers composants tels que les informations sur l'auteur de la vidéo, la liste des commentaires, le contenu des commentaires et les détails des commentateurs. Analysons en profondeur chaque étape avec des exemples de code professionnels et efficaces.

Informations sur l'auteur de la vidéo Scraping

Lors de la récupération des commentaires de la page vidéo, il est essentiel de conserver des enregistrements précis de la vidéo correspondante et de son téléchargeur pour une analyse et une attribution complètes. Pour récupérer les informations sur l'auteur de la vidéo à partir d'une page vidéo TikTok, nous pouvons extraire des détails tels que le nom d'utilisateur, l'URL du profil et la photo du profil.

Éléments HTML de l'auteur de la vidéo

Voici un exemple de code illustrant comment réaliser cela :

1
2
3
4
5
6
def scrape_video_author_info(soupe):
    auteur_info = {}
    auteur_info["Nom d'utilisateur"] = soupe.select_one("span[data-e2e='browse-username']").texte.strip()
    auteur_info[« URL du profil utilisateur »] = soupe.select_one("a[data-e2e='browse-user-avatar']")[href]
    auteur_info[« URL de l'image de l'utilisateur »] = soupe.select_one("une image[data-e2e='browse-user-avatar']")["src"]
    retourner auteur_info

Scraping de la liste des commentaires

Pour extraire la liste des commentaires d'une page vidéo TikTok, nous pouvons extraire les éléments HTML contenant les commentaires.

Liste des commentaires des éléments HTML

Voici un exemple de code illustrant comment réaliser cela :

1
2
3
def scrape_comments_listing(soupe):
    commentaires_listing = soup.select("div[data-e2e='search-comment-container'] > div[class*='CommentListContainer'] > div[class*='DivCommentItemContainer']")
    retourner commentaires_listing

Récupération du contenu des commentaires

Pour extraire le contenu de chaque commentaire, nous pouvons extraire le contenu textuel des éléments du commentaire.

Élément HTML de contenu de commentaire

Voici un exemple de code illustrant comment réaliser cela :

1
2
3
4
def gratter_le_contenu_du_commentaire(commentaire):
    commentaire_content = {}
    commentaire_contenu[« Contenu du commentaire »] = commentaire.select_one("div[class*='DivCommentContentContainer'] p[data-e2e='comment-level-1'] > span").texte.strip()
    retourner commentaire_content

Détails du commentateur de scraping

Pour extraire des détails sur le commentateur, tels que son nom d'utilisateur et l'URL de son profil, nous pouvons extraire des informations pertinentes des éléments du commentaire.

Détails du commentateur Éléments HTML

Voici un exemple de code illustrant comment réaliser cela :

1
2
3
4
5
def scrape_commenter_details(commentaire):
    commenter_details = {}
    commenter_details[« Nom d'utilisateur du commentateur »] = commentaire.select_one("div[class*='DivCommentContentContainer'] span[data-e2e='comment-username-1']").texte.strip()
    commenter_details[« URL du profil du commentateur »] = commentaire.select_one("div[class*='DivCommentContentContainer'] > a[data-e2e='comment-avatar-1']").obtenir(href)
    retourner commenter_details

Code complet

Maintenant, combinons ces fonctions de scraping dans un exemple de code complet qui extrait les informations sur l'auteur de la vidéo, la liste des commentaires, le contenu des commentaires et les détails des commentateurs :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
à partir de base d'exploration importer API d'exploration
à partir de bs4 importer BeautifulSoup
importer json

# Initialiser le Crawlbase Objet CrawlingAPI
crawling_api = API d'exploration({"jeton": "CRAWLBASE_JS_TOKEN"})

choix = {
    'ajax_wait': 'vrai',
    'page_wait': 10000,
    "user_agent": "Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64) AppleWebKit/537.36 (KHTML, comme Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0"
}

# Fonction pour récupérer du HTML en utilisant Crawlbase Crawling API
def récupérer_html_crawlbase(url):
    de défis crawling_api, options
    Essai:
        réponse = crawling_api.get(url, options)
        if réponse['en-têtes']['pc_status']== «200 ':
            retourner réponse['corps'].décoder(« utf-8 »)
        d'autre:
            impression(f"Échec de la récupération du code HTML. Crawlbase code d'état : {réponse['en-têtes']['pc_status']}")
            retourner Aucun
    sauf Exception as e:
        impression(f"Une erreur s'est produite : {str(e)}")
        retourner Aucun

def scrape_video_author_info(soupe):
    auteur_info = {}
    auteur_info["Nom d'utilisateur"] = soupe.select_one("span[data-e2e='browse-username']").texte.strip()
    auteur_info[« URL du profil utilisateur »] = soupe.select_one("a[data-e2e='browse-user-avatar']")[href]
    auteur_info[« URL de l'image de l'utilisateur »] = soupe.select_one("une image[data-e2e='browse-user-avatar']")["src"]
    retourner auteur_info

def scrape_comments_listing(soupe):
    commentaires_listing = soup.select("div[data-e2e='search-comment-container'] > div[class*='CommentListContainer'] > div[class*='DivCommentItemContainer']")
    retourner commentaires_listing

def gratter_le_contenu_du_commentaire(commentaire):
    commentaire_content = {}
    commentaire_contenu[« Contenu du commentaire »] = commentaire.select_one("div[class*='DivCommentContentContainer'] p[data-e2e='comment-level-1'] > span").texte.strip()
    retourner commentaire_content

def scrape_commenter_details(commentaire):
    commenter_details = {}
    commenter_details[« Nom d'utilisateur du commentateur »] = commentaire.select_one("div[class*='DivCommentContentContainer'] span[data-e2e='comment-username-1']").texte.strip()
    commenter_details[« URL du profil du commentateur »] = commentaire.select_one("div[class*='DivCommentContentContainer'] > a[data-e2e='comment-avatar-1']").obtenir(href)
    retourner commenter_details

def principal†
    données_grattées = {}

    # Récupérer le contenu HTML de la page vidéo TikTok
    html_content = fetch_html_crawlbase("https://www.tiktok.com/@khaby.lame/video/7255327059302419738")

    # Analyser le contenu HTML à l'aide de BeautifulSoup
    soupe = BeautifulSoup(contenu_html, « Parseur HTML »)

    # Récupérer les informations sur l'auteur de la vidéo
    données récupérées[« Informations sur l'auteur »] = scrape_video_author_info(soupe)

    # Récupérer la liste des commentaires
    commentaires_listing = scrape_comments_listing(soupe)

    # Parcourez les commentaires et récupérez le contenu des commentaires et les détails des commentateurs
    liste_de_commentaires = []
    pour commentaire in commentaires_liste:
        commentaires_détail = {}
        comments_detail.update(scrape_comment_content(commentaire))
        comments_detail.update(scrape_commenter_details(commentaire))
        comments_list.append(comments_detail)

    données récupérées[« Commentaires »] = liste_de_commentaires

    # Imprimer les résultats récupérés
    impression(json.dumps(données_grattées, indent=2, assurer_ascii=Faux))

if __nom__ == "__principale__":
    principale()

Exemple de sortie :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
{
  « Informations sur l'auteur »: {
    "Nom d'utilisateur": "khaby.boiteux",
    « URL du profil utilisateur »: "https://www.tiktok.com/@khaby.lame",
    « URL de l'image de l'utilisateur »: "./Faites toujours confiance à Robert Downey Jr #oppenheimer #imax _ TikTok_files/6595ee956e2304779514b56c2f9cb666~c5_100x100.jpeg"
  },
  "Commentaires": [
    {
      « Contenu du commentaire »: "C'est cet Iron Man ?",
      « Nom d'utilisateur du commentateur »: "des noix",
      « URL du profil du commentateur »: "https://www.tiktok.com/@dezzznuts19"
    },
    {
      « Contenu du commentaire »: "attends, il est vivant ?",
      « Nom d'utilisateur du commentateur »: « M. Blurryface »,
      « URL du profil du commentateur »: "https://www.tiktok.com/@mr.blurryfacee21"
    },
    {
      « Contenu du commentaire »: "Tony?😳",
      « Nom d'utilisateur du commentateur »: "FranciscoRosalles",
      « URL du profil du commentateur »: "https://www.tiktok.com/@franciscorosalles"
    },
    {
      « Contenu du commentaire »: "est-ce que c'est Tony",
      « Nom d'utilisateur du commentateur »: « Mort profonde »,
      « URL du profil du commentateur »: "https://www.tiktok.com/@gt.clock.a"
    },
    {
      « Contenu du commentaire »: "deuxième",
      « Nom d'utilisateur du commentateur »: "🇷🇸☠️🇷🇸",
      « URL du profil du commentateur »: "https://www.tiktok.com/@tiktok_zenox7"
    },
    {
      « Contenu du commentaire »: "le meilleur 💗💗💗",
      « Nom d'utilisateur du commentateur »: "🍓 L eti 🍓",
      « URL du profil du commentateur »: "https://www.tiktok.com/@leticiiamurilloo"
    },
    {
      « Contenu du commentaire »: "l'homme de fer 😱",
      « Nom d'utilisateur du commentateur »: "Poisson-copter",
      « URL du profil du commentateur »: "https://www.tiktok.com/@hugobosskingman.cool88"
    },
    ..... plus
  ]
}

5. Gérer la pagination dans le scraping des commentaires TikTok

TikTok utilise souvent le défilement infini pour charger davantage de commentaires de manière dynamique. Pour gérer la pagination, nous pouvons utiliser Crawlbase Crawling API scroll paramètre. Par défaut, l'intervalle de défilement est défini sur 10 secondes, mais vous pouvez utiliser scroll_interval paramètre pour le modifier. Voici un exemple de gestion de la pagination à l'aide du Crawlbase Crawling API:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Fonction pour récupérer du contenu HTML avec pagination par défilement
def récupérer_html_avec_pagination_crawlbase(url):
    de défis API d'exploration

    # Installation Crawlbase Paramètres API pour la pagination de défilement
    choix = {
        'ajax_wait': 'vrai',
        'utilisateur_agent': 'Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64) AppleWebKit/537.36 (KHTML, comme Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0',
        'rouleau': 'vrai',
        'intervalle_de_défilement': 20000  # (20 secondes)
    }

    Essai:
        réponse = crawling_api.get(url, options)
        if réponse['en-têtes']['pc_status']== «200 ':
            retourner réponse['corps'].décoder(« utf-8 »)
        d'autre:
            impression(f"Échec de la récupération du code HTML. Crawlbase code d'état : {réponse['en-têtes']['pc_status']}")
            retourner Aucun
    sauf Exception as e:
        impression(f"Une erreur s'est produite : {str(e)}")
        retourner Aucun

6. Sauvegarde des données de commentaires TikTok récupérées

Après avoir récupéré avec succès les commentaires TikTok, il est essentiel de sauvegarder les données extraites pour une analyse plus approfondie et une référence ultérieure. Ici, nous allons explorer deux méthodes courantes pour stocker les données de commentaires TikTok récupérées : l'enregistrement dans un fichier Excel et l'enregistrement dans une base de données SQLite.

Enregistrement dans un fichier Excel

Les fichiers Excel offrent un moyen pratique d'organiser et d'analyser les données récupérées, ce qui en fait un choix populaire pour stocker des informations structurées telles que les commentaires TikTok. Python propose des bibliothèques telles que pandas pour gérer efficacement les trames de données et openpyxl pour écrire des données dans des fichiers Excel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
importer pandas as pd

# Fonction pour enregistrer les données de commentaire dans Excel
def enregistrer_dans_excel(données, nom de fichier):
    author_info = données[« Informations sur l'auteur »]
    commentaires = données[« Commentaires »]

    # Aplatir les informations sur l'auteur
    flat_author_info = {'Auteur_Nom d'utilisateur':info_auteur['Nom d'utilisateur'],
                        'URL_du_profil_de_l'auteur':info_auteur[« URL du profil utilisateur »],
                        'URL_de_l'image_de_l'auteur':info_auteur[« URL de l'image de l'utilisateur »]}

    # Aplatir les commentaires
    flat_comments = [{'Comment_Contenu': commentaire[« Contenu du commentaire »],
                      'Commenter_Username': commentaire[« Nom d'utilisateur du commentateur »],
                      'URL_du_profil_du_commentateur': commentaire[« URL du profil du commentateur »]} pour commentaire in commentaires]

    # Créer des DataFrames
    auteur_df = pd.DataFrame([flat_author_info])
    commentaires_df = pd.DataFrame(flat_comments)

    # Enregistrer dans Excel
    avec pd.ExcelWriter(nom de fichier) as écrivain:
        author_df.to_excel(écrivain, nom_feuille=« Informations sur l'auteur », indice=Faux)
        commentaires_df.to_excel(écrivain, nom_feuille=« Commentaires », indice=Faux)

    impression(« Les données ont été enregistrées avec succès dans le fichier Excel. »)

save_to_excel(data, filename):

Cette fonction enregistre les données de commentaire ainsi que les informations sur l'auteur dans un fichier Excel. Elle prend deux paramètres : data, un dictionnaire contenant à la fois les informations sur l'auteur et les commentaires, et filename, le nom du fichier Excel dans lequel les données seront enregistrées.

À l'intérieur de la fonction :

  • Les informations et commentaires de l'auteur sont extraits du data dictionnaire.
  • Les informations sur l'auteur sont aplaties dans un dictionnaire flat_author_info.
  • Les commentaires sont aplatis dans une liste de dictionnaires flat_comments.
  • Deux DataFrames sont créés : un pour les informations sur l'auteur (author_df) et un pour les commentaires (comments_df).
  • Les DataFrames sont écrits dans différentes feuilles du fichier Excel à l'aide de pd.ExcelWriter.
  • Enfin, un message de réussite est imprimé indiquant que les données ont été enregistrées dans le fichier Excel.

Enregistrement dans la base de données SQLite

Les bases de données SQLite offrent une solution légère et autonome pour stocker des données structurées localement. Python fournit le module sqlite3 pour interagir avec les bases de données SQLite. Nous pouvons créer une table pour stocker les données des commentaires TikTok et insérer les données récupérées dans la table.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
importer sqlite3

# Fonction pour créer une table si elle n'existe pas
def créer_une_table_si_n'existe_pas(nom_fichier_base_de_données, nom_table):
    Essai:
        conn = sqlite3.connect(nom_fichier_base_de_données)
        # Créer ou ajouter à la table SQLite
        créer_table_sql = f'''CRÉER UNE TABLE SI ELLE N'EXISTE PAS {table_name} (
                                Auteur_Nom d'utilisateur TEXTE,
                                Texte de l'URL du profil de l'auteur,
                                Auteur_Photo_URL TEXTE,
                                Commentaire_Contenu TEXTE,
                                Commenter_Nom d'utilisateur TEXTE,
                                Commenter_Profile_URL TEXT
                              )'''
        conn.execute(créer_table_sql)
        conn.commit()
    sauf sqlite3.Erreur as e:
        impression(f"Erreur lors de la création de la table SQLite : {e}")
    enfin:
        conn.close()

# Fonction pour enregistrer les données de commentaire dans la base de données SQLite
def enregistrer_dans_sqlite(données, nom_fichier_base_de_données, nom_table):
    author_info = données[« Informations sur l'auteur »]
    commentaires = données[« Commentaires »]
    Essai:
        conn = sqlite3.connect(nom_fichier_base_de_données)

        # Aplatir les informations sur l'auteur
        flat_author_info = (info_auteur['Nom d'utilisateur'],
                            auteur_info[« URL du profil utilisateur »],
                            auteur_info[« URL de l'image de l'utilisateur »])

        # Insérer les données de l'auteur dans SQLite
        insert_author_sql = f'''INSÉRER DANS {table_name} (
                                Auteur_Nom d'utilisateur,
                                URL_du_profil_de_l'auteur,
                                Auteur_Photo_URL,
                                Commentaire_Contenu,
                                Commentateur_Nom d'utilisateur,
                                URL du profil du commentateur
                              ) VALEURS (?, ?, ?, ?, ?, ?)'''

        pour commentaire in commentaires:
            flat_comment = (flat_author_info[0],  # Auteur_Nom_d'utilisateur
                            flat_author_info[1],  # URL_du_profil_de_l'auteur
                            flat_author_info[2],  # URL_de_l'image_de_l'auteur
                            commentaire[« Contenu du commentaire »],
                            commentaire[« Nom d'utilisateur du commentateur »],
                            commentaire[« URL du profil du commentateur »])

            conn.execute(insert_author_sql, flat_comment)

        conn.commit()
        impression(« Les données ont été enregistrées avec succès dans la base de données SQLite. »)
    sauf sqlite3.Erreur as e:
        impression(f"Erreur lors de l'enregistrement des données dans la base de données SQLite : {e}")
    enfin:
        conn.close()

create_table_if_not_exists(db_filename, table_name):

Cette fonction garantit qu'une table existe dans la base de données SQLite avec le nom spécifié. Elle prend deux paramètres : db_filename, le nom de fichier de la base de données SQLite, et table_name, le nom de la table à créer ou dont l'existence doit être vérifiée.

À l'intérieur de la fonction :

  • Une connexion est établie à la base de données SQLite.
  • Une requête SQL est exécutée pour créer la table si elle n'existe pas déjà. La table se compose de champs pour les informations sur l'auteur (nom d'utilisateur, URL du profil et URL de l'image) et les informations sur les commentaires (contenu, nom d'utilisateur du commentateur et URL du profil du commentateur).
  • Si une erreur se produit lors de la création de la table, un message d'erreur est imprimé.
  • Enfin, la connexion à la base de données est fermée.

save_to_sqlite(data, db_filename, table_name):

Cette fonction enregistre les données de commentaire ainsi que les informations sur l'auteur dans une base de données SQLite. Elle prend trois paramètres : data, un dictionnaire contenant à la fois des informations sur l'auteur et des commentaires, db_filename, le nom de fichier de la base de données SQLite, et table_name, le nom de la table dans laquelle les données seront enregistrées.

À l'intérieur de la fonction :

  • Les informations et commentaires de l'auteur sont extraits du data dictionnaire.
  • Les informations sur l'auteur sont aplaties dans un tuple flat_author_info.
  • Pour chaque commentaire, les informations sur l'auteur et les données du commentaire sont combinées dans un tuple flat_comment.
  • Une requête SQL est exécutée pour insérer les données dans la table SQLite.
  • Si une erreur se produit lors de l’insertion de données, un message d’erreur est imprimé.
  • Enfin, la connexion à la base de données est fermée.

7. Code complet avec pagination et sauvegarde

Maintenant, étendons notre exemple de code complet de la section 4 pour inclure la gestion de la pagination et l'enregistrement des données de commentaires dans les bases de données Excel et SQLite :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
à partir de base d'exploration importer API d'exploration
à partir de bs4 importer BeautifulSoup
importer pandas as pd
importer sqlite3

# Initialiser le Crawlbase Objet CrawlingAPI
crawling_api = API d'exploration({"jeton": "CRAWLBASE_JS_TOKEN"})

def récupérer_html_avec_pagination_crawlbase(url):
    # ... (inchangé)

def scrape_video_author_info(soupe):
    # ... (inchangé)

def scrape_comments_listing(soupe):
    # ... (inchangé)

def gratter_le_contenu_du_commentaire(commentaire):
    # ... (inchangé)

def scrape_commenter_details(commentaire):
    # ... (inchangé)

def enregistrer_dans_excel(données, nom de fichier):
    # ... (inchangé)

def créer_une_table_si_n'existe_pas(nom_fichier_base_de_données, nom_table):
    # ... (inchangé)

def enregistrer_dans_sqlite(données, nom_fichier_base_de_données, nom_table):
    # ... (inchangé)

def principal†
    données_grattées = {}

    # Récupérer le contenu HTML de la page vidéo TikTok
    html_content = récupérer_html_avec_pagination_crawlbase("https://www.tiktok.com/@khaby.lame/video/7255327059302419738")

    # Analyser le contenu HTML à l'aide de BeautifulSoup
    soupe = BeautifulSoup(contenu_html, « Parseur HTML »)

    # Récupérer les informations sur l'auteur de la vidéo
    données récupérées[« Informations sur l'auteur »] = scrape_video_author_info(soupe)

    # Récupérer la liste des commentaires
    commentaires_listing = scrape_comments_listing(soupe)

    # Parcourez les commentaires et récupérez le contenu des commentaires et les détails des commentateurs
    liste_de_commentaires = []
    pour commentaire in commentaires_liste:
        commentaires_détail = {}
        comments_detail.update(scrape_comment_content(commentaire))
        comments_detail.update(scrape_commenter_details(commentaire))
        comments_list.append(comments_detail)

    données récupérées[« Commentaires »] = liste_de_commentaires

    # Enregistrer les données de commentaire dans la base de données Excel et SQLite
    save_to_excel(données récupérées, "tiktok_comments.xlsx")
    create_table_si_n'existe_pas("tiktok_comments.db", "commentaires")
    save_to_sqlite(données récupérées, "tiktok_comments.db", "commentaires")

if __nom__ == "__principale__":
    principale()

Cet exemple de code étendu montre comment gérer la pagination lors de la récupération des commentaires TikTok et enregistrer les données de commentaires récupérées dans les bases de données Excel et SQLite pour une analyse plus approfondie.

tiktok_comments.xlsx Déposer & comments aperçu du tableau:

Instantané des fichiers de sortie

Félicitations pour avoir réussi à configurer votre outil de grattage de commentaires TikTok à l'aide de Crawlbase Crawling API et Python ! J'espère que ce guide vous a été utile pour récupérer les commentaires TikTok.

N'hésitez pas à explorer notre liste organisée de Grattoirs TikTok pour améliorer vos capacités de scraping :

(I.e. Meilleurs grattoirs TikTok
(I.e. Comment récupérer les résultats de recherche de TikTok
(I.e. Comment gratter Facebook
(I.e. Comment scraper Linkedin
(I.e. Comment récupérer des données Twitter
(I.e. Comment récupérer des données Instagram
(I.e. Comment récupérer des vidéos YouTube

Pour de plus amples options de personnalisation et fonctionnalités avancées, se référer au Crawlbase Crawling API documentation. Si vous avez des questions ou des commentaires, notre équipe de soutien est toujours disponible pour vous aider dans votre parcours de scraping Web.

8. Foire aux questions (FAQ)

Q. Pourquoi récupérer les commentaires TikTok ?

L'extraction des commentaires TikTok permet aux utilisateurs d'extraire des informations, des tendances et des sentiments précieux à partir du contenu généré par les utilisateurs. En analysant les commentaires, les entreprises peuvent mieux comprendre les préférences, les opinions et les commentaires de leur public. Les chercheurs peuvent également utiliser les données des commentaires pour les études sociales, l'analyse des sentiments et l'analyse des tendances.

Bien que le scraping des commentaires TikTok soit techniquement contraire aux conditions d'utilisation de TikTok, la légalité du scraping Web dépend de divers facteurs, notamment de l'objectif du scraping, du respect des lois sur la protection des données et du respect des conditions d'utilisation du site Web. Il est essentiel de consulter et de respecter les conditions d'utilisation et les réglementations de protection des données de TikTok avant de récupérer des commentaires de la plateforme.

Q. Que pouvez-vous apprendre en récupérant les commentaires TikTok ?

L'extraction des commentaires TikTok peut fournir des informations précieuses sur l'engagement des utilisateurs, l'analyse des sentiments, les tendances du contenu et les données démographiques du public. En analysant les données des commentaires, les utilisateurs peuvent identifier les sujets populaires, évaluer les réactions du public à un contenu spécifique et comprendre le sentiment des utilisateurs envers les marques, les produits ou les services.

Q. Comment gérer le contenu dynamique lors de la récupération des commentaires TikTok ?

La gestion du contenu dynamique lors de l'extraction des commentaires TikTok implique l'utilisation de techniques telles que des navigateurs headless ou des outils d'automatisation pour afficher la page dans son intégralité avant d'extraire les commentaires. Les utilisateurs peuvent également utiliser des API d'extraction web comme Crawlbase Crawling API, qui fournissent des capacités de rendu JavaScript pour extraire le contenu dynamique avec précision. Ces méthodes garantissent que tous les commentaires, y compris ceux chargés dynamiquement, sont capturés efficacement pendant le processus de récupération.