Erstellen von Echtzeitdatensätzen in Pharo: Abrufen von YouTube-Statistiken | von Joshua Dias Barreto | Juni 2023

Von
alleserledigt
-
0
27


Pharo ist eine rein objektorientierte Programmiersprache Und eine leistungsstarke Umgebung, die auf Einfachheit und sofortiges Suggestions ausgerichtet ist (denken Sie an IDE und Betriebssystem in einem). Wenn Sie Pharo noch nicht installiert haben, können Sie es installieren, indem Sie den Anweisungen unter folgen https://pharo.org/download.

Sobald Sie es installiert und Ihr Pharo-Picture geöffnet haben, öffnen Sie Playground (Strg+O+W).

Führen Sie zur Set up den folgenden Code (Strg+D) im Playground aus Datenrahmen.

Metacello new
baseline: 'DataFrame';
repository: 'github://PolyMathOrg/DataFrame/src';
load.

Sie benötigen die Kanal-ID des YouTube-Kanals. Sie können es daraus erhalten Grundstück.

Sie benötigen außerdem Ihr persönliches YouTube-API Schlüssel, der nicht öffentlich geteilt werden sollte. Befolgen Sie diese Anweisungen, um Ihren YouTube-API-Schlüssel zu erhalten:

  • Einloggen in Google Developers Console.
  • Erstellen Sie ein neues Projekt.
  • Klicken Sie im neuen Projekt-Dashboard auf APIs erkunden und aktivieren.
  • Navigieren Sie in der Bibliothek unter YouTube-APIs zu YouTube Information API v3.
  • Aktivieren Sie die API.
  • Erstellen Sie einen Ausweis.
  • Der API-Schlüssel wird auf dem Bildschirm angezeigt.

Erstellen eines leeren DataFrame

videosDataFrame := DataFrame new: 0 @ 7.
videosDataFrame columnNames:
#( 'title' 'description' 'likes' 'views' 'feedback' 'uploadDate'
'videoUrl' ).
  • Wir erstellen einen leeren DataFrame namens videosDataFrame mit 0 Zeilen und 7 Spalten.
  • Wir legen die Spaltennamen für den DataFrame fest 'title', 'description', 'likes', 'views', 'feedback', 'uploadDate'Und 'videoUrl'.

Einrichten der API-Anfrage

url := 'https://www.googleapis.com/youtube/v3/search?key=' , apiKey
, '&channelId=' , channelID
, '&half=snippet,id&order=date&maxResults=50'.
response := ZnEasy get: url.
json := NeoJSONReader fromString: response contents.
  • Wir beginnen mit der Einrichtung der URL für die API-Anfrage. Dazu gehören der YouTube-Daten-API-Endpunkt, der API-Schlüssel, die Kanal-ID sowie der gewünschte Teil und die gewünschte Reihenfolge der Antwort.
  • Wir benutzen das ZnEasy Klasse aus dem Zinc-Paket, um eine HTTP-GET-Anfrage an die URL zu senden und die Antwort zu speichern.
  • Wir erstellen eine NeoJSONReader Instanz, um den Antwortinhalt zu analysieren und die JSON-Daten in der zu speichern json Variable. JSON bietet ein äußerst benutzerfreundliches Format für menschliche Leser und für Nicht-JavaScript-Maschinenleser. Im Vergleich zu XML und anderen Typen ist es sowohl menschlich als auch maschinenfreundlich.

Inspektion der json Variable:

1) Wählen Sie die aus gadgets Style :

2) Klicken Sie auf ein beliebiges Wörterbuch, das sich in „Elemente“ befindet:

3) Wählen Sie die aus snippet Style :

Von all diesen Schlüsseln brauchen wir nur die description , publishedAt Und title Schlüssel.
Beachten Sie, dass der Wert von publishedAt ist etwa so: 2023–06–09T14:28:26Z, wir brauchen nur das, was vor „T“ steht.
Nachdem der gesamte Wert in der Variablen gespeichert wurde uploadDate :

uploadDate := uploadDate copyFrom: 1 to: (uploadDate findString: 'T') - 1.

Videostatistiken abrufen

Um die Anzahl der Likes, Views und Kommentare zu erhalten, müssen wir eine weitere API-Anfrage stellen. Dazu benötigen wir die Video-ID des YouTube-Movies und Ihren YouTube-API-Schlüssel.

urlStat := 'https://www.googleapis.com/youtube/v3/movies?key=' , apiKey
, '&id=' , videoId , '&half=statistics'.
responseStat := ZnEasy get: urlStat.
jsonStat := NeoJSONReader fromString: responseStat contents.

Noch einmal können Sie inspizieren jsonStat um die nötigen Schlüssel zu finden.
gadgets -> statistics -> { likeCount , viewCount , commentCount }

 json at: 'gadgets' ifPresent: [ :items |
items do: [ :item |
videoStats := DataSeries new.
videoId := (item at: 'id' ifAbsent: [ #(  ) ])
at: 'videoId'
ifAbsent: [ nil ].
videoTitle := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'title'
ifAbsent: [ nil ].
uploadDate := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'publishedAt'
ifAbsent: [ nil ].
uploadDate := uploadDate
copyFrom: 1
to: (uploadDate findString: 'T') - 1.
videoDescription := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'description'
ifAbsent: [ nil ].
videoUrl := videoId ifNotNil: [
'https://www.youtube.com/watch?v=' , videoId ].
urlStat := 'https://www.googleapis.com/youtube/v3/movies?key=' , apiKey
, '&id=' , videoId , '&half=statistics'.
responseStat := ZnEasy get: urlStat.
jsonStat := NeoJSONReader fromString: responseStat contents.
videoStats at: 'title' put: videoTitle. 
videoStats at: 'description' put: videoDescription.
jsonStat at: 'gadgets' ifPresent: [ :itemsStat |
itemsStat do: [ :itemStat |
videoStats
at: 'likes'
put: ((itemStat at: 'statistics' ifAbsent: [ #(  ) ])
at: 'likeCount'
ifAbsent: [ 'N/A' ]).
videoStats
at: 'views'
put: ((itemStat at: 'statistics' ifAbsent: [ #(  ) ])
at: 'viewCount'
ifAbsent: [ 'N/A' ]).
videoStats
at: 'feedback'
put: ((itemStat at: 'statistics' ifAbsent: [ #(  ) ])
at: 'commentCount'
ifAbsent: [ 'N/A' ])  ]].
videoStats identify: videoId.
videoStats at: 'uploadDate' put: uploadDate.
videoStats at: 'videoUrl' put: videoUrl.
videosDataFrame addRow: videoStats ] ].
videosDataFrame examine.
  • Wir durchlaufen die Elemente in der JSON-Antwort unter dem Schlüssel gadgets.
  • Für jeden Artikel erstellen wir einen neuen DataSeries genannt videoStats um die Videostatistiken zu speichern.
  • Wir rufen die Video-ID, den Titel, das Add-Datum und die Beschreibung ab und erstellen die Video-URL aus den JSON-Daten.
  • Wir stellen eine weitere API-Anfrage, um die detaillierten Statistiken für das Video mithilfe der Video-ID abzurufen.
  • Wir aktualisieren die videoStats mit den abgerufenen Statistiken wie Likes, Views und Kommentare.
  • Zum Schluss fügen wir das hinzu videoStats zum videosDataFrame Verwendung der addRow: Methode.

Der gesamte Code

videosDataFrame := DataFrame new: 0 @ 7.
videosDataFrame columnNames:
#( 'title' 'description' 'likes' 'views' 'feedback' 'uploadDate'
'videoUrl' ).
url := 'https://www.googleapis.com/youtube/v3/search?key=' , apiKey
, '&channelId=' , channelID
, '&half=snippet,id&order=date&maxResults=50'.
response := ZnEasy get: url.
json := NeoJSONReader fromString: response contents.
json at: 'gadgets' ifPresent: [ :items |
items do: [ :item |
videoStats := DataSeries new.
videoId := (item at: 'id' ifAbsent: [ #(  ) ])
at: 'videoId'
ifAbsent: [ nil ].
videoTitle := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'title'
ifAbsent: [ nil ].
uploadDate := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'publishedAt'
ifAbsent: [ nil ].
uploadDate := uploadDate
copyFrom: 1
to: (uploadDate findString: 'T') - 1.
videoDescription := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'description'
ifAbsent: [ nil ].
videoUrl := videoId ifNotNil: [
'https://www.youtube.com/watch?v=' , videoId ].
urlStat := 'https://www.googleapis.com/youtube/v3/movies?key=' , apiKey
, '&id=' , videoId , '&half=statistics'.
responseStat := ZnEasy get: urlStat.
jsonStat := NeoJSONReader fromString: responseStat contents.
videoStats at: 'title' put: videoTitle. 
videoStats at: 'description' put: videoDescription.
jsonStat at: 'gadgets' ifPresent: [ :itemsStat |
itemsStat do: [ :itemStat |
videoStats
at: 'likes'
put: ((itemStat at: 'statistics' ifAbsent: [ #(  ) ])
at: 'likeCount'
ifAbsent: [ 'N/A' ]).
videoStats
at: 'views'
put: ((itemStat at: 'statistics' ifAbsent: [ #(  ) ])
at: 'viewCount'
ifAbsent: [ 'N/A' ]).
videoStats
at: 'feedback'
put: ((itemStat at: 'statistics' ifAbsent: [ #(  ) ])
at: 'commentCount'
ifAbsent: [ 'N/A' ])  ]].
videoStats identify: videoId.
videoStats at: 'uploadDate' put: uploadDate.
videoStats at: 'videoUrl' put: videoUrl.
videosDataFrame addRow: videoStats ] ].
videosDataFrame examine.

Möglicherweise ist Ihnen aufgefallen, dass das Schreiben des gesamten Codes im Playground ziemlich chaotisch ist. Es empfiehlt sich, jeden Codeabschnitt als Methoden zu schreiben. Hier ist ein schrittweiser Ansatz, um den Code lesbarer zu machen und eine sauberere Implementierung zu erreichen.

Erstellen Sie ein neues Paket

  1. Öffnen Sie den Systembrowser (Strg + O + B) oder browse -> System Browser .
  2. Klicken Sie mit der rechten Maustaste auf ein vorhandenes Paket und wählen Sie es dann aus + new bundle .
  3. Wählen Sie als Paketnamen einen beliebigen Namen. Nehmen wir an, wir haben dem Paket einen Namen gegeben DatasetGenerator .

Erstellen Sie eine neue Klasse

Sie werden dies in der Klassendefinition sehen:

Object subclass: #MyClass
instanceVariableNames: '' 
classVariableNames: ''
bundle: 'DatasetGenerator'

Geben wir unserer Klasse einen Namen YouTubeAPI dazu ersetzen #MyClass mit #YouTubeAPI .

Erstellen Sie eine klassenseitige Methode

getVideoStatistics: apiKey videoID: videoID statDataSeries: videoStats
| url response json |
url := 'https://www.googleapis.com/youtube/v3/movies?key=' , apiKey
, '&id=' , videoID , '&half=statistics'.
response := ZnEasy get: url.
json := NeoJSONReader fromString: response contents.
json at: 'gadgets' ifPresent: [ :items |
items do: [ :item |
videoStats
at: 'likes'
put: ((item at: 'statistics' ifAbsent: [ #(  ) ])
at: 'likeCount'
ifAbsent: [ 'N/A' ]).
videoStats
at: 'views'
put: ((merchandise at: 'statistics' ifAbsent: [ #(  ) ])
at: 'viewCount'
ifAbsent: [ 'N/A' ]).
videoStats
at: 'feedback'
put: ((merchandise at: 'statistics' ifAbsent: [ #(  ) ])
at: 'commentCount'
ifAbsent: [ 'N/A' ]) ] ].
videoStats identify: videoID.
^ videoStats

Diese Methode wird verwendet, um Statistiken wie „Gefällt mir“-Angaben, Aufrufe und Kommentare abzurufen.
Erstellen Sie eine weitere klassenseitige Methode:

getVideoStatisticsForChannel: apiKey channelID: channelID
| url response json videosDataFrame |
url := 'https://www.googleapis.com/youtube/v3/search?key=' , apiKey
, '&channelId=' , channelID
, '&half=snippet,id&order=date&maxResults=50'.
response := ZnEasy get: url.
json := NeoJSONReader fromString: response contents.
videosDataFrame := DataFrame new: 0 @ 7.
videosDataFrame columnNames:
#( 'title' 'description' 'likes' 'views' 'feedback' 'uploadDate'
'videoUrl' ).
json at: 'gadgets' ifPresent: [ :items |
items do: [ :item |
| videoId videoUrl videoStats videoTitle videoDescription uploadDate |
videoStats := DataSeries new.
videoId := (item at: 'id' ifAbsent: [ #(  ) ])
at: 'videoId'
ifAbsent: [ nil ].
videoTitle := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'title'
ifAbsent: [ nil ].
uploadDate := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'publishedAt'
ifAbsent: [ nil ].
uploadDate := uploadDate
copyFrom: 1
to: (uploadDate findString: 'T') - 1.
videoDescription := (merchandise at: 'snippet' ifAbsent: [ #(  ) ])
at: 'description'
ifAbsent: [ nil ].
videoUrl := videoId ifNotNil: [
'https://www.youtube.com/watch?v=' , videoId ].
videoStats := self
getVideoStatistics: apiKey
videoID: videoId
statDataSeries: videoStats.
videoStats at: 'title' put: videoTitle.
videoStats at: 'description' put: videoDescription.
videoStats at: 'uploadDate' put: uploadDate.
videoStats at: 'videoUrl' put: videoUrl.
videosDataFrame add: videoStats ] ].
^ videosDataFrame

Nachdem wir nun die klassenseitigen Methoden implementiert haben, müssen wir nur noch den folgenden Codeausschnitt (Strg + D) ausführen, um den gewünschten statistischen DataFrame zu erhalten.

apiKey := 'Kind your API key right here'.
channelID := 'Enter the Channel ID of the specified YouTube Channel'.
videoStatisticsDataFrame := YouTubeAPI
getVideoStatisticsForChannel: apiKey
channelID: channelID
videoStatisticsDataFrame examine.

Mit diesem Datensatz können verschiedene Aufgaben im Zusammenhang mit maschinellem Lernen, Datenwissenschaft und NLP durchgeführt werden, wie zum Beispiel:

  1. Vorhersage der Anzahl von Likes, Views oder Kommentaren zukünftiger Movies.
  2. Pattern der Anzahl der Likes, Aufrufe oder Kommentare basierend auf der Beschreibung oder dem Titel des Movies.
  3. Vorhersage des Add-Datums zukünftiger Movies.

Dies sind nur einige Ideen, es gibt viele andere Möglichkeiten, solche Datensätze zu analysieren.
Obwohl sich dieses Tutorial speziell auf die YouTube-API bezog, ist es hilfreich beim Extrahieren von Daten/Statistiken aus einer beliebigen API in einen DataFrame.



Source link

VERWANDTE ARTIKELMEHR VOM AUTOR

HINTERLASSEN SIE EINE ANTWORT

Please enter your comment!
Please enter your name here