Mit der YouTube Data API können Clientanwendungen YouTube-Inhalte in Form von Google Data API-Feeds abrufen und aktualisieren. Mit den YouTube Data API-Feeds kannst du in deiner Clientanwendung Videos, Kommentare, Antworten, Playlists, Nutzerprofile und Nutzerkontakte abrufen, suchen und aktualisieren sowie nach Videos suchen, die bestimmten Kriterien entsprechen.
Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der YouTube Data API, sondern auch Beispiele für die Interaktion mit der API über die Python-Clientbibliothek. Für die Verwendung der Python-Clientbibliothek benötigen Sie Python 2.0 oder höher sowie die Module „Element Tree“, „httplib“ und „urllib“. Weitere Informationen finden Sie unter Abhängigkeitsmodule.
Hilfe bei der Einrichtung der Python-Clientbibliothek finden Sie im Einstiegsleitfaden. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Python-Clientbibliothek für die Interaktion mit YouTube verwendet wird, findest du auf der Seite zum Protokoll im Entwicklerleitfaden.
Informationen zu diesem Dokument
Zielgruppe
Dieses Dokument richtet sich an Programmierer, die Clientanwendungen schreiben möchten, die mit der Python-Clientbibliothek mit YouTube interagieren können. Es enthält eine Reihe von Beispielen für grundlegende Interaktionen mit Daten-APIs.
Weitere Informationen zur YouTube Data API findest du im Referenzleitfaden.
In diesem Dokument wird davon ausgegangen, dass Sie die allgemeinen Konzepte des Google Data APIs-Protokolls kennen und mit Python programmieren können.
Referenzinformationen zu den Python-Klassen und ‑Methoden finden Sie in den PyDocs (für die Dienstklasse und die Datenklassen), die im Quellcode enthalten sind.
Dokumentstruktur
Diese FAQs sind in folgende Abschnitte gegliedert:
-
Im Abschnitt Authentifizierung werden die beiden Authentifizierungsmethoden beschrieben, mit denen API-Vorgänge einem bestimmten Nutzerkonto zugeordnet werden können. Außerdem werden in diesem Abschnitt die Unterschiede zwischen der Authentifizierung für die YouTube Data API und anderen Google Data APIs beschrieben. In diesem Dokument wird bei den Erläuterungen zu bestimmten API-Funktionen klar angegeben, ob für die Funktion eine Nutzerauthentifizierung erforderlich ist. Im Allgemeinen müssen alle Anfragen, die Video- oder Feeddaten ändern, authentifiziert werden. Für Lesezugriffsanfragen auf öffentliche Videos ist keine Authentifizierung erforderlich.
-
Im Abschnitt Videofeeds und ‑einträge findest du eine Beispiel-API-Antwort und erfährst, wie du Informationen zu einem einzelnen Video aus einer Liste von Videos oder einer Reihe von Suchergebnissen extrahierst. Außerdem wird hier erläutert, wie du auf Metadaten zu einem bestimmten Videoeintrag zugreifen kannst. Abschließend wird in diesem Abschnitt erläutert, wie ein einzelner Videoeintrag aktualisiert wird.
-
Im Abschnitt Videos abrufen und nach Videos suchen wird beschrieben, wie du bestimmte Videolisten abrufen kannst, z. B. einen Standardfeed mit den beliebtesten Videos auf YouTube. Andere Videolisten umfassen Videos, die von einem bestimmten Nutzer hochgeladen wurden, und Listen mit Videos, die zu einem bestimmten Video passen. Außerdem wird in diesem Abschnitt erläutert, wie du mit der API Nutzern die Möglichkeit gibst, die Videothek von YouTube nach bestimmten Suchbegriffen oder Kategorien zu durchsuchen.
-
Im Abschnitt Videos hochladen werden kurz zwei Möglichkeiten beschrieben, wie Nutzer über Ihre App Videos auf YouTube hochladen können. Außerdem wird in diesem Abschnitt beschrieben, wie du Videos als Antwort auf andere Videos hochladen kannst.
-
Im Abschnitt Videos aktualisieren und löschen wird beschrieben, wie du mit der API Informationen zu einem YouTube-Video aktualisierst. Außerdem wird beschrieben, wie ein Video mithilfe der API entfernt werden kann.
-
Im Abschnitt Communityfunktionen verwenden werden API-Funktionen beschrieben, mit denen deine Nutzer mit YouTube-Videos interagieren können. Hier erfährst du, wie du eine Altersfreigabe, einen Kommentar oder eine Beschwerde zu einem vorhandenen Video posten kannst. Mit der API kannst du auch Listen mit Videokommentaren abrufen.
-
Im Abschnitt Videos speichern und erfassen wird beschrieben, wie du mit der API auf Lieblingsvideos, Videoplaylists und YouTube-Kanalabonnements zugreifen, sie erstellen und aktualisieren kannst. Außerdem wird gezeigt, wie du Videoplaylists und Favoriten ändern kannst, indem du Videos hinzufügst oder entfernst.
-
Im Abschnitt Nutzerinteraktion aktivieren wird beschrieben, wie Sie mit der API Nutzerprofile abrufen und aktualisieren. Außerdem wird hier beschrieben, wie Sie Nutzerkontakte abrufen, hinzufügen, aktualisieren und löschen.
Erste Schritte
Voraussetzungen
Mit den YouTube Data API-Feeds kannst du in deiner Clientanwendung nach Videos, Kommentaren, Antworten, Playlists, Abos, Nutzerprofilen und mehr suchen, diese abrufen und aktualisieren.Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der YouTube Data API, sondern auch Beispiele für die Interaktion mit der API über die Python-Clientbibliothek. Für die Verwendung der Python-Clientbibliothek benötigen Sie Python 2.2 oder höher sowie die Module „Element Tree“, „httplib“ und „urllib“. Weitere Informationen finden Sie unter Abhängigkeitsmodule.
Weitere Informationen zur Konfiguration Ihrer Umgebung finden Sie im Startleitfaden. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Python-Clientbibliothek für die Interaktion mit YouTube verwendet wird, findest du auf der Seite zum Protokoll im Entwicklerleitfaden.
Die folgenden Code-Snippets können in Ihren Code kopiert und eingefügt und an Ihre Anforderungen angepasst werden.
Bevor du mit der YouTube Data API Aktionen ausführen kannst, musst du ein gdata.youtube.service.YouTubeService-Objekt initialisieren, wie unten gezeigt. Die unten aufgeführten import-Anweisungen führen automatisch weitere Importe aus den gdata.media- und gdata.geo-Modulen aus. Hinweis: Alle Aktionen, mit Ausnahme des Abrufens öffentlicher Inhalte, erfordern eine Authentifizierung.
import gdata.youtube import gdata.youtube.service yt_service = gdata.youtube.service.YouTubeService() # Turn on HTTPS/SSL access. # Note: SSL is not available at this time for uploads. yt_service.ssl = True
Die meisten Methodenbeispiele in diesem Leitfaden beziehen sich auf eine Instanz von gdata.youtube.service.YouTubeService. Es kann von Vorteil sein, die nicht authentifizierten Anfragen über den interaktiven Python-Interpreter zu testen.
Hinweis: Die Python-Clientbibliothek muss dem Pfad richtig hinzugefügt werden. Führen Sie das bereitgestellte setup.py-Script aus, um es zu installieren. Weitere Informationen finden Sie im Einstiegsleitfaden.
Authentifizierung
Die Python-Clientbibliothek kann sowohl mit öffentlichen als auch mit privaten Feeds verwendet werden. Öffentliche Feeds sind schreibgeschützt und erfordern keine Authentifizierung. Für private Feeds musst du dich bei den YouTube-Servern authentifizieren.
Die Authentifizierung kann über die ClientLogin (für Desktop-Apps) oder die AuthSub (für Webanwendungen) erfolgen.
Entwicklerschlüssel und Client-ID festlegen
Ein Entwicklerschlüssel identifiziert den YouTube-Entwickler, der eine API-Anfrage sendet. Mit einer Client-ID wird Ihre Anwendung zu Protokollierungs- und Fehlerbehebungszwecken identifiziert.
Wenn Sie eine API-Anfrage mit der Python-Clientbibliothek stellen, wird der X-GData-Key-Anfrageheader verwendet, um Ihren Entwicklerschlüssel anzugeben, und der X-GData-Client-Header, um Ihre Client-ID anzugeben. Der Entwicklerschlüssel und die Client-ID können unabhängig vom verwendeten Authentifizierungsschema für das YouTubeService-Objekt festgelegt werden:
yt_service.developer_key = 'ABCxyz123...' yt_service.client_id = 'My-Client_id'
Du musst dich für einen YouTube-Entwicklerschlüssel registrieren.
AuthSub-Authentifizierung für Webanwendungen
Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer in YouTube-/Google-Konten authentifizieren müssen. Der Betreiber benötigt keinen Zugriff auf den Nutzernamen und das Passwort des YouTube-Nutzers. Es sind nur spezielle AuthSub-Tokens erforderlich.
Wenn der Nutzer Ihre Anwendung zum ersten Mal besucht, wurde er noch nicht bei den Google-Diensten authentifiziert. In diesem Fall müssen Sie dem Nutzer einen Link zur Verfügung stellen, über den er Google auffordert, den Zugriff Ihrer Anwendung auf sein YouTube-Konto zu autorisieren. Die Python-Clientbibliothek bietet eine Funktion zum Generieren dieser URL. Mit dem folgenden Code wird ein Link zur Seite AuthSubRequest eingerichtet.
def GetAuthSubUrl(): next = 'http://www.example.com/video_upload.pyc' scope = 'http://gdata.youtube.com' secure = False session = True yt_service = gdata.youtube.service.YouTubeService() return yt_service.GenerateAuthSubURL(next, scope, secure, session) authSubUrl = GetAuthSubUrl() print '<a href="%s">Login to your Google account</a>' % authSubUrl
Beachten Sie die Parameter, die an die Methode GenerateAuthSubURL der Dienstobjekte gesendet werden:
- next: Die URL der Seite, auf die YouTube den Nutzer weiterleiten soll, nachdem er deiner Anwendung Zugriff auf sein Konto gewährt hat.
- scope: Gibt an, dass die Anwendung nur auf YouTube API-Feeds zugreift.
- secure: Das zurückgegebene Token ist kein sicheres Token.
- session: Gibt an, dass dieses Token gegen ein wiederverwendbares Sitzungstoken eingetauscht werden kann.
Die zurückgegebene URL sieht in etwa so aus:
https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fgdata.youtube.com&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fvideo_upload.pyc
Der Nutzer kann dann über den Link in seinem YouTube-Konto anmelden. Nachdem der Nutzer deiner Anwendung den Zugriff auf sein Konto erlaubt hat, wird er zurück zur next-URL weitergeleitet. Der URL wird als Abfrageparameter ein Einmaltoken-Wert angehängt. Die URL sieht in etwa so aus:
http://www.example.com/video_upload.pyc?token=Abc123...
Im nächsten Abschnitt wird beschrieben, wie Sie dieses Token aktualisieren. Im folgenden Snippet wird eine Möglichkeit zum Abrufen dieses Tokens aus der URL veranschaulicht:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters[[]'token' ]
Auf ein Sitzungstoken umstellen
Aus Sicherheitsgründen ist dieses Token nur einmal verwendbar. Sie müssen es daher gegen ein Sitzungstoken austauschen. Dieser Vorgang wird in der AuthSub-Dokumentation beschrieben. Das folgende Code-Snippet zeigt, wie das Token aktualisiert wird.
yt_service = gdata.youtube.service.YouTubeService() yt_service.SetAuthSubToken(authsub_token) yt_service.UpgradeToSessionToken()
Dieser Tokenwert stellt ein AuthSub-Token zur einmaligen Verwendung dar. Da oben session = True angegeben wurde, kann dieses Token mit der Methode UpgradeToSessionToken gegen ein AuthSub-Sitzungstoken eingetauscht werden, die den Dienst AuthSubSessionToken aufruft.
Dein YouTubeService-Objekt ist jetzt vollständig authentifiziert und kann für alle weiteren Anfragen an die YouTube API verwendet werden. AuthSub-Sitzungstokens laufen nicht ab, es sei denn, du erteilst einen ausdrücklichen Widerrufsantrag oder der Nutzer hebt den Zugriff auf seiner YouTube-Kontoseite unter Zugelassene Websites auf.
ClientLogin-Authentifizierung für installierte Anwendungen
Die ClientLogin-Authentifizierung wird in installierten Anwendungen verwendet, die den Nutzernamen und das Passwort des Nutzers entweder speichern oder abfragen können. Wenn du diese Authentifizierungsmethode verwenden möchtest, musst du die Methode ProgrammaticLogin von YouTubeService aufrufen, die von der Klasse gdata.service.GDataService geerbt wurde. Dabei musst du die ID und das Passwort des Nutzers angeben, in dessen Namen dein Client die Authentifizierungsanfrage sendet.
yt_service = gdata.youtube.service.YouTubeService() yt_service.email = 'jo@gmail.com' yt_service.password = 'mypassword' yt_service.source = 'my-example-application' yt_service.ProgrammaticLogin()
Nachdem die Anmeldedaten festgelegt wurden, kann das Objekt YouTubeService für die Verarbeitung aller weiteren Anfragen verwendet werden. Damit du Uploads und alle Arten von Schreibanfragen (z. B. das Hinzufügen von Kommentaren) an die YouTube API senden kannst, musst du bei der Authentifizierung auch deinen Entwicklerschlüssel und deine Client-ID an das yt_service-Objekt übergeben:
# A complete client login request yt_service.email = 'jo@gmail.com' yt_service.password = 'mypassword' yt_service.source = 'my-example-application' yt_service.developer_key = 'ABC123...' yt_service.client_id = 'my-example-application' yt_service.ProgrammaticLogin()
Das Objekt YouTubeService legt automatisch die richtigen X-GData-Key- und X-GData-Client-Header fest, wenn die Attribute developer_key und client_id festgelegt sind.
Hinweis:Weitere Informationen zu den AuthSub- und ClientLogin-Mechanismen finden Sie in der Authentifizierungsdokumentation für Google Data APIs.
Videofeeds und ‑einträge
Die YouTube Data API bietet mehrere Videofeeds, die Listen von Videos enthalten, z. B. Standardfeeds, Uploads, Abos und Favoriten. Die URL für jeden Feed ist im Referenzleitfaden dokumentiert.
Videofeed anzeigen
Viele Feeds in der YouTube API bestehen aus Videoeinträgen. Diese Feeds können am einfachsten als gdata.youtube.YouTubeVideoFeed-Objekte modelliert werden, die jeweils eine Reihe von gdata.youtube.YouTubeVideoEntry-Objekten enthalten. Jeder Videoeintrag entspricht genau einem Video auf YouTube und enthält Informationen zum Video.
Die grundlegende Struktur zum Abrufen einer Liste von Videos besteht darin, eine URL zu einem Videofeed zu erstellen und dann die Einträge einzeln zu verarbeiten. Das sieht in etwa so aus:
def GetAndPrintVideoFeed(uri):
yt_service = gdata.youtube.service.YouTubeService()
feed = yt_service.GetYouTubeVideoFeed(uri)
for entry in feed.entry:
PrintEntryDetails(entry) # full documentation for this function
Im Abschnitt Videos abrufen und nach Videos suchen werden viele gängige Feed-URLs und die Abrufmethoden verschiedener Videofeeds beschrieben.
Bestimmten Videoeintrag abrufen
Wenn Sie die Video-ID kennen, können Sie nur die Informationen für einen bestimmten Videoeintrag abrufen. Die Einstiegs-URL basiert auf der Video-ID:
http://gdata.youtube.com/feeds/api/videos/videoID
Im folgenden Code wird eine gdata.youtube.YouTubeVideoEntry abgerufen, die einem Video auf YouTube entspricht:
entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')
Videoinhalte
Es gibt viele Metadaten, die aus einem gdata.youtube.YouTubeVideoEntry-Objekt abgerufen werden können, z. B. Thumbnails, Player-URLs und Videodauer. Im folgenden Code wird gezeigt, wie Sie einige dieser Informationen abrufen. Die Python-Clientbibliothek abstrahiert die meisten dieser Funktionen, indem XML-Elemente Klassen zugeordnet werden. Die meisten wichtigen Informationen zu einem YouTubeVideoEntry-Eintrag sind in den untergeordneten Elementen des Attributs media (mit einem gdata.media.Group-Objekt) im Eintrag verfügbar (entspricht dem XML-Element media:group). Im folgenden Beispiel wird gezeigt, wie Videometadaten abgerufen werden:
def PrintEntryDetails(entry):
print 'Video title: %s' % entry.media.title.text
print 'Video published on: %s ' % entry.published.text
print 'Video description: %s' % entry.media.description.text
print 'Video category: %s' % entry.media.category[[]0].text
print 'Video tags: %s' % entry.media.keywords.text
print 'Video watch page: %s' % entry.media.player.url
print 'Video flash player URL: %s' % entry.GetSwfUrl()
print 'Video duration: %s' % entry.media.duration.seconds
# non entry.media attributes
print 'Video geo location: %s' % entry.geo.location()
print 'Video view count: %s' % entry.statistics.view_count
print 'Video rating: %s' % entry.rating.average
# show alternate formats
for alternate_format in entry.media.content:
if 'isDefault' not in alternate_format.extension_attributes:
print 'Alternate format: %s | url: %s ' % (alternate_format.type,
alternate_format.url)
# show thumbnails
for thumbnail in entry.media.thumbnail:
print 'Thumbnail url: %s' % thumbnail.url
Hinweis:Weitere Informationen zum Generieren der erforderlichen Informationen zum Einbetten eines Videos mit einem Player in deine Seite findest du im Protokollleitfaden.
Videos abrufen und suchen
Standardfeeds abrufen
Die YouTube Data API bietet einen Standardfeed mit den beliebtesten Videos auf YouTube. Die API unterstützte früher auch andere Standardfeeds, die inzwischen eingestellt wurden. Weitere Informationen finden Sie im Entwicklerleitfaden.
Die URL für den Feed der beliebtesten Videos auf YouTube hat folgendes Format:
http://gdata.youtube.com/feeds/api/standardfeeds/most_popular
Hinweis: Sie können auch sprachspezifische Standardfeeds abrufen, indem Sie eine Gebietsschema-ID im Format http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID angeben. Die beliebtesten Videos in Japan wären beispielsweise: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. Eine vollständige Liste der mutmaßlichen Gebietsschema-IDs finden Sie im Referenzhandbuch .
def PrintVideoFeed(feed):
for entry in feed.entry:
PrintEntryDetails(entry)
def GetAndPrintFeedByUrl:
yt_service = gdata.youtube.service.YouTubeService()
# You can retrieve a YouTubeVideoFeed by passing in the URI
uri = 'http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular'
PrintVideoFeed(yt_service.GetYouTubeVideoFeed(uri))
Von einem bestimmten Nutzer hochgeladene Videos abrufen
Jeder YouTube-Nutzer hat einen Videofeed, der den von ihm hochgeladenen Videos zugewiesen ist.http://gdata.youtube.com/feeds/api/users/username/uploads
Der folgende Code zeigt, wie ein Feed mit von Nutzern hochgeladenen Inhalten abgerufen und angezeigt wird:
def GetAndPrintUserUploads(username): yt_service = gdata.youtube.service.YouTubeService() uri = 'http://gdata.youtube.com/feeds/api/users/%s/uploads' % username PrintVideoFeed(yt_service.GetYouTubeVideoFeed(uri))
Hinweis:Du kannst auch den String „default“ anstelle von username verwenden, um Videos für den aktuell authentifizierten Nutzer abzurufen.
Ähnliche Videos abrufen
Wenn du ähnliche Videos abrufen möchtest, übergebe die Video-ID des gdata.youtube.YouTubeVideoEntry-Objekts an die Methode GetYouTubeRelatedVideoFeed des gdata.youtube.service.YouTubeService-Objekts. Dadurch wird ein YouTubeVideoFeed-Objekt mit zugehörigen Einträgen abgerufen.
related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')
Videos suchen
Mit der YouTube Data API kannst du eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen. Du kannst beispielsweise nach Videoeinträgen suchen, die von einem bestimmten Autor veröffentlicht wurden, nach Videoformat oder nach einem bestimmten Keyword. Dazu erstellen Sie ein gdata.service.YouTubeVideoQuery-Objekt mit Ihren speziellen Suchkriterien und übergeben es an die Methode YouTubeQuery von gdata.youtube.service.YouTubeService.
Im folgenden Beispiel wird gezeigt, wie eine Suchanfrage ausgeführt wird, bei der die Ergebnisse nach der Anzahl der Aufrufe sortiert werden, einschließlich eingeschränkter Videos (in der API als „Racy“ bezeichnet):
def SearchAndPrint(search_terms): yt_service = gdata.youtube.service.YouTubeService() query = gdata.youtube.service.YouTubeVideoQuery() query.vq = search_terms query.orderby = 'viewCount' query.racy = 'include' feed = yt_service.YouTubeQuery(query) PrintVideoFeed(feed)
Die Klasse gdata.service.Query und Unterklassen wie YouTubeVideoQuery sind für die Erstellung von Feed-URLs verantwortlich. Die oben gezeigte VideoQuery erstellt eine URL, die dem folgenden entspricht:
http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount
Im Folgenden finden Sie einige der gängigsten YouTubeVideoQuery-Eigenschaften zum Festlegen von Suchparametern:
author- Legt den Autor des Eintrags fest. „Autor“ ist ein Synonym für den YouTube-Nutzernamen.
format- Gibt ein Videoformat an. Nimmt numerische Parameter zur Angabe einer von zwei Arten von RTSP-Streaming-URLs für die Wiedergabe von Videos auf Mobilgeräten oder einer HTTP-URL zum einbettbaren Flash-Player an.
racy- Gibt an, ob eingeschränkt zulässige Inhalte in die Ergebnisse einbezogen werden sollen. Es werden nur zwei Parameter akzeptiert: „include“ (einschließen) oder „exclude“ (ausschließen).
max_results- Legt die maximale Anzahl der Einträge fest, die gleichzeitig zurückgegeben werden sollen.
start_index- Legt den Index (ab 1) des ersten abzurufenden Ergebnisses fest (für die Paginierung).
orderby- Legt die Reihenfolge fest, in der Einträge aufgelistet werden sollen, z. B. nach
relevance,viewCount,publishedoderrating. time- Legt einen Zeitraum fest, um Standardfeedergebnisse auf
today,this_week,this_monthoderall_timezu begrenzen. vq- Legt einen Suchbegriff fest. Es wird in allen Videometadaten wie Titeln, Tags und Beschreibungen nach dem angegebenen String gesucht.
Hinweis:Weitere Informationen zu Abfrageparametern findest du im Referenzhandbuch für die YouTube Data API und im Referenzhandbuch für Google Data APIs.
Mithilfe von Kategorien und Keywords suchen
Du kannst die Suchergebnisse so einschränken, dass nur Videos angezeigt werden, die mit einer bestimmten Gruppe von Kategorien und Keywords übereinstimmen. Im Referenzleitfaden wird beschrieben, wie Sie sowohl vordefinierte YouTube-Kategorien (z. B. „Musik“, „Personen“ und „Blogs“) als auch benutzerdefinierte Keywords (Tags) angeben.
Im folgenden Code wird gezeigt, wie Sie mithilfe von Keywords (Tags) suchen, indem Sie die Suchbegriffe in Kleinbuchstaben ändern. Hinweis: Da einige Wörter (z. B. „Comedy“) sowohl eine YouTube-Kategorie als auch ein Keyword sein können, wird bei Kategorie- und Keyword-Suchanfragen folgende Konvention verwendet: Ein großgeschriebenes Wort („Comedy“) steht für eine YouTube-Kategorie, während ein kleingeschriebenes Wort („comedy“) für ein Keyword steht.
def SearchAndPrintVideosByKeywords(list_of_search_terms):
yt_service = gdata.youtube.service.YouTubeService()
query = gdata.youtube.service.YouTubeVideoQuery()
query.orderby = 'viewCount'
query.racy = 'include'
for search_term in list_of_search_terms:
new_term = search_term.lower()
query.categories.append('/%s' % new_term)
feed = yt_service.YouTubeQuery(query)
PrintVideoFeed(feed)
Nach Entwickler-Tags suchen
Entwickler-Tags sind zusätzliche, ausgeblendete Keywords, mit denen Entwickler Inhalte taggen können, die über ihre App von Endnutzern hochgeladen wurden. Entwickler-Tags werden mit dem Entwicklerschlüssel abgeglichen, der in den Headern beim Upload festgelegt wurde. Diese Keywords sind nicht öffentlich sichtbar und können zum Abrufen von Videos verwendet werden. Wenn du nach Videos mit einem bestimmten Entwickler-Tag suchen möchtest, sende eine allgemeine Suchanfrage an die YouTube Data API und verwende dabei deinen Entwicklerschlüssel. Geben Sie das Kategorienschema und das Entwickler-Tag an, mit dem die Videos übereinstimmen müssen. Über die folgende URL kannst du einen Feed mit Videos abrufen, die mit deinem Entwickler-Tag (in unserem Beispiel „dein_tag_hier“) übereinstimmen:
developer_tag_uri = 'http://gdata.youtube.com/feeds/videos/-/%7Bhttp%3A%2F%2Fgdata.youtube.com%2Fschemas%2F2007%2Fdevelopertags.cat%7Dyour_tag_here' yt_service = gdata.youtube.service.YouTubeService() PrintVideoFeed(yt_service.GetYouTubeVideoFeed(developer_tag_uri))
Hochladen von Videos
In den Diagrammen im Protokollleitfaden finden Sie eine allgemeine Übersicht über den Uploadvorgang. Es gibt zwei Möglichkeiten, Videos hochzuladen:
- entweder durch direkten Upload des Videos über deine Server
- oder indem du zuerst die Metadaten sendest und der Nutzer das Video dann über die browserbasierte Uploadmethode direkt auf YouTube hochlädt.
Direkter Upload
Wenn du ein Video hochladen möchtest, musst du zuerst ein neues gdata.youtube.YouTubeVideoEntry-Objekt erstellen und ihm ein gdata.media.Group-Objekt mit den erforderlichen Metadaten übergeben. Im folgenden Beispiel wird das Quicktime-Video „mytestmovie.mov“ mit den folgenden Eigenschaften auf YouTube hochgeladen:
| Attribut | Wert |
|---|---|
| Titel | Mein Testfilm |
| Kategorie | Autos |
| Keywords | Autos, lustig |
| Beschreibung | Meine Beschreibung |
| Dateiname | mytestmovie.mov |
| MIME-Typ der Datei | video/quicktime |
| Ist das Video privat? | falsch |
| Aufnahmeort | 37,-122 (lat,long) |
| Entwickler-Tags | mydevelopertag, anotherdevelopertag |
Mit dem folgenden Code wird eine leere YouTubeVideoEntry zum Hochladen erstellt. Für die Methode InsertVideoEntry auf dem YouTubeService sind die folgenden Parameter erforderlich:
video_entry: dasgdata.youtube.VideoEntry-Objekt mit Metadatenfilename_or_handle– ein dateiähnliches Objekt oder der Dateiname, aus dem das Video gelesen wirdyoutube_username: Optionaler String, der den Nutzernamen angibt, in dessen Konto dieses Video hochgeladen werden soll. Ihr Konto benötigt natürlich die entsprechenden Berechtigungen. Standardmäßig ist das Konto des aktuell authentifizierten Nutzers festgelegt.content_type: Optionaler String, der den MIME-Typ des hochzuladenden Videos angibt.
yt_service auf ein vollständig authentifiziertes YouTubeService-Objekt bezieht.
# prepare a media group object to hold our video's meta-data
my_media_group = gdata.media.Group(
title=gdata.media.Title(text='My Test Movie'),
description=gdata.media.Description(description_type='plain',
text='My description'),
keywords=gdata.media.Keywords(text='cars, funny'),
category=[[]gdata.media.Category(
text='Autos',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='Autos')],
player=None
)
# prepare a geo.where object to hold the geographical location
# of where the video was recorded
where = gdata.geo.Where()
where.set_location((37.0,-122.0))
# create the gdata.youtube.YouTubeVideoEntry to be uploaded
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group,
geo=where)
# set the path for the video file binary
video_file_location = '/path/to/my/file.mov'
new_entry = yt_service.InsertVideoEntry(video_entry, video_file_location)
Wenn wir unser Video mit optionalen Entwickler-Tags taggen wollten (weitere Informationen finden Sie unter Nach Entwickler-Tags suchen), hätten wir vor dem Aufruf von InsertVideoEntry die Methode AddDeveloperTags verwenden können:
developer_tags = [[]'some_tag_01', 'another_tag'] video_entry.AddDeveloperTags(developer_tags)
Hinweis: Wenn du Videos als privat hochladen möchtest, muss der gdata.media.Group ein Attribut für die Sichtbarkeit übergeben werden:
my_media_group = gdata.media.Group(
title=gdata.media.Title(text='My Test Movie'),
description=gdata.media.Description(description_type='plain',
text='My description'),
keywords=gdata.media.Keywords(text='cars, funny'),
category=[[]gdata.media.Category(
text='Autos',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='Autos')],
player=None,
private=gdata.media.Private()
)
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)
# assuming that video_file_location points to a valid path
new_entry = yt_service.InsertVideoEntry(video_entry, video_file_location)
Browserbasierter Upload
Der browserbasierte Upload funktioniert fast genau wie der direkte Upload, mit der Ausnahme, dass du die Binärdatei nicht in derselben Anfrage hochlädst, mit der du die Videometadaten sendest. Stattdessen erstellen Sie einfach eine YouTubeVideoEntry, die nur Metadaten enthält. Dieser Videoeintrag wird dann über einen speziellen Link auf dem YouTube API-Server veröffentlicht. Die XML-Antwort enthält einen token und einen url, mit denen die Binärdatei dann über ein standardmäßiges HTML-Formular hochgeladen werden kann.
# create media group as usual
my_media_group = gdata.media.Group(
title=gdata.media.Title(text='My Test Movie'),
description=gdata.media.Description(description_type='plain',
text='My description'),
keywords=gdata.media.Keywords(text='cars, funny'),
category=[[]gdata.media.Category(
text='Autos',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='Autos')],
player=None
)
# create video entry as usual
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)
# upload meta data only
response = yt_service.GetFormUploadToken(video_entry)
# parse response tuple and use the variables to build a form (see next code snippet)
post_url = response[[]0]
youtube_token = response[[]1]
Der obige Code gibt einen Link und ein Token aus, mit dem ein HTML-Formular erstellt wird, das im Browser des Nutzers angezeigt wird. Unten siehst du ein einfaches Beispielformular. youtube_token steht dabei für den Inhalt des zurückgegebenen Token-Elements, das wie oben gezeigt aus YouTubeVideoEntry abgerufen wird. Damit der Nutzer nach dem Senden des Formulars zu Ihrer Website weitergeleitet wird, fügen Sie dem post_url wie unten gezeigt einen next-Parameter hinzu. Dieser funktioniert genauso wie der next-Parameter eines AuthSub-Links. Der einzige Unterschied besteht darin, dass hier anstelle eines Einmaltokens eine status- und eine id-Variable als URL-Parameter zurückgegeben werden.
next = 'http://example.com/post_video_upload.pyc'
form = """<form action="%s?nexturl=%s" method="post" enctype="multipart/form-data">
<input name="file" type="file"/>
<input name="token" type="hidden" value="%s"/>
<input value="Upload Video File" type="submit" />
</form>""" % (post_url, next, youtube_token)
Eine Antwort für einen erfolgreichen Upload würde dann so aussehen:
http://example.com/post_video_upload.pyc?status=200&id=ABC123
Der Parameter status gibt den HTTP-Transaktionsstatus der Uploadtransaktion zurück. Der Parameter id gibt die YouTube-Video-ID zurück, die dem hochgeladenen Video zugewiesen wurde.
Uploadstatus wird geprüft
Nach dem Hochladen eines Videos ist es sofort im Upload-Feed eines authentifizierten Nutzers zu sehen. Sie wird jedoch erst nach der Verarbeitung auf der Website veröffentlicht. Videos, die abgelehnt wurden oder deren Upload fehlgeschlagen ist, sind ebenfalls nur im Uploadfeed des authentifizierten Nutzers zu sehen. Im folgenden Code wird der Status einer YouTubeVideoEntry geprüft, um festzustellen, ob sie noch nicht veröffentlicht wurde oder abgelehnt wurde.
upload_status = yt_service.CheckUploadStatus(new_entry) if upload_status is not None: video_upload_state = upload_status[[]0] detailed_message = upload_status[[]1]
Videos aktualisieren und löschen
Videoinformationen aktualisieren
Wenn du die Videometadaten aktualisieren möchtest, aktualisiere einfach das YouTubeVideoEntry-Objekt und verwende dann die Methode UpdateVideoEntry der Objekte YouTubeService. Diese Methode nimmt als Parameter ein YouTubeVideoEntry mit aktualisierten Metadaten an.
# assuming we have a video entry that was just posted in our 'new_entry' variable new_entry.media.title.text = 'My Updated Video Title' new_entry.media.description.text = 'Just updated' updated_entry = yt_service.UpdateVideoEntry(new_entry)
Ein Video löschen
Das Löschen eines Videos ist ganz einfach. Dazu musst du nur die DeleteVideoEntry des YouTubeService-Objekts aufrufen.
response = yt_service.DeleteVideoEntry(entry_to_be_deleted) if response: print 'Video successfully deleted!'
Community-Funktionen nutzen
Bewertung hinzufügen
Wenn du ein Video bewerten möchtest, verwende die Methode AddRating des Objekts YouTubeService. Du kannst deine eigenen Videos nicht bewerten. Die Bewertungen müssen zwischen 1 und 5 liegen:
video_id_to_rate = 'Ncakifd_16k' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id_to_rate) response = yt_service.AddRating(3, video_entry)
Kommentare
Kommentare zu einem Video abrufen
Wenn du ein YouTubeVideoEntry-Objekt oder eine einfache Video-ID hast, kannst du mit der Methode GetYouTubeVideoCommentFeed des YouTubeService-Objekts einen Feed mit den Kommentaren zum Video abrufen und ausdrucken. Der resultierende Feed ist ein gdata.youtube.YouTubeCommentFeed, der aus gdata.youtube.YouTubeCommentEntry-Objekten besteht. Der Feed kann wie jeder andere Feed geparst werden:
video_id = 'ABC123...' comment_feed = yt_service.GetYouTubeVideoCommentFeed(video_id=video_id) for comment_entry in comment_feed.entry: print comment_entry.ToString()
Kommentar hinzufügen
Wenn Sie einen neuen Kommentar hinzufügen möchten, verwenden Sie einfach die Methode AddComment des Objekts YouTubeService. Für die Methode ist ein vollständiges YouTubeVideoEntry-Objekt erforderlich, das kommentiert werden soll, sowie ein String, der den Kommentar darstellt:
my_comment = 'what a boring test video' video_id = '9g6buYJTt_g' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id) yt_service.AddComment(comment_text=my_comment, video_entry=video_entry)
Videoantworten
Eine YouTube-Videoantwort war ein Video, das als Antwort auf ein zweites Video verknüpft wurde. Die Funktion für Videoantworten wurde eingestellt, wie in dieser Ankündigung erläutert. Vorhandene Videoantworten sind weiterhin verfügbar. Es ist jedoch nicht mehr möglich, eine Liste der Videoantworten für ein Video abzurufen, neue Videoantworten hochzuladen oder Videoantworten zu löschen. Du kannst aber das Video löschen, das in einer Videoantwort verwendet wurde. Daher werden diese Funktionen auch nicht mehr in der API unterstützt.
API-Anfragen für Videoantwortvorgänge geben jetzt Folgendes zurück:
- Eine Anfrage zum Abrufen von Videoantworten für ein Video gibt eine leere Liste zurück.
- Bei einer Anfrage zum Hinzufügen einer Videoantwort wird der HTTP-Antwortcode 403 zurückgegeben.
- Bei einer Anfrage zum Löschen einer Videoantwort wird der HTTP-Antwortcode 403 zurückgegeben.
Melden eines Videos
Eine Beschwerde gegen ein Video wird mit der Methode AddComplaint auf dem Objekt YouTubeService hinzugefügt. Der Begriff der Beschwerde muss einer gültigen Kategorie entsprechen. Weitere Informationen finden Sie im Abschnitt Eine Beschwerde hinzufügen des Protokollleitfadens.
video_id_to_flag = 'Ncakifd_16k'
complaint_term = 'VIOLENCE'
complaint_text = ('Please ignore this complaint. '
'I\'m testing a YouTube API and needed to issue '
'a complaint to test the add complaint function. ')
response = yt_service.AddComplaint(complaint_text, complaint_term, video_id_to_flag)
Videos speichern und erfassen
Gespeicherte Videos
Lieblingsvideos eines Nutzers abrufen
YouTube-Nutzer können sich angesehene Videos als Favoriten markieren. Die allgemeine URL für den Lieblingsfeed eines Nutzers lautet:
http://gdata.youtube.com/feeds/api/users/username/favorites
Die Lieblingsvideos eines Nutzers kannst du mit der Methode GetUserFavoritesFeed des Objekts YouTubeService abrufen. Die Methode nimmt einen optionalen String als Parameter an, der den YouTube-Nutzernamen des Nutzers darstellt, dessen Lieblingsfeed abgerufen werden soll.
favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')
Der zurückgegebene Feed ist ein regulärer Videofeed mit YouTubeVideoEntry-Objekten.
Hinweis:Alternativ kannst du den String default übergeben, um Favoriten für den aktuell authentifizierten Nutzer abzurufen. Das ist das Standardverhalten der GetUserFavoritesFeed-Methode, wenn kein Nutzername angegeben wird.
Favoriten hinzufügen
Wenn du ein Lieblingsvideo hinzufügen möchtest, verwende die Methode AddVideoEntryToFavorites des Objekts YouTubeService. Die Parameter sind die hinzuzufügende YouTubeVideoEntry und optional der Nutzername, zu dessen Favoriten sie hinzugefügt werden soll (standardmäßig der aktuell authentifizierte Nutzer).
video_id = 'Ncakifd_16k' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id) response = yt_service.AddVideoEntryToFavorites(video_entry) # The response, if successfully posted is a YouTubeVideoEntry if isinstance(response, gdata.youtube.YouTubeVideoEntry): print 'Video successfully added to favorites'
Favoriten löschen
Wenn Sie einen Favoriten löschen möchten, verwenden Sie einfach die Methode DeleteVideoEntryFromFavorites des YouTubeService-Objekts.
video_id = 'Ncakifd_16k' response = yt_service.DeleteVideoEntryFromFavorites(video_id) if response is True: print 'Video deleted from favorites'
Playlists
Jeder YouTube-Nutzer hat einen Playlist-Feed, der alle von ihm erstellten Playlists enthält. Jede Playlist hat dann einen Feed mit allen Videos, die sie enthält.
Nutzerplaylists abrufen
Wenn du eine Liste aller Playlists eines Nutzers manuell abrufen möchtest, verwende die folgende URL:
http://gdata.youtube.com/feeds/api/users/username/playlists
Mit der Python-Clientbibliothek können Sie die Methode GetYouTubePlaylistFeed des Objekts YouTubeService verwenden:
playlist_feed = yt_service.GetYouTubePlaylistFeed(username='gdpython') # instead of passing in a username, you can also pass the URI to the playlist feed: playlist_feed = yt_service.GetYouTubePlaylistFeed(uri='http://gdata.youtube.com/feeds/api/users/default/playlists')
Hinweis:Anstatt einen bestimmten Nutzernamen (z. B. „gdpython“ im Beispiel oben) zu übergeben, können Sie auch den String 'default' übergeben, um sich auf den aktuell authentifizierten Nutzer zu beziehen.
Ein gdata.youtube.YouTubePlaylistFeed stellt einen Feed mit gdata.youtube.YouTubePlaylistEntry-Objekten dar. Diese beziehen sich auf die einzelnen Playlists, die ein Nutzer haben kann. Videoeinträge in einer bestimmten Playlist werden als gdata.youtube.YouTubePlaylistVideoEntry-Objekte dargestellt. Diese Objekte ähneln mit wenigen Ausnahmen normalen gdata.youtube.YouTubeVideoEntry-Objekten. Auf die Videos können benutzerdefinierte Titel und Beschreibungen angewendet werden. Ein Positionsfeld gibt an, an welcher Stelle in der Playlist das Video angezeigt wird.
Playlist-Informationen abrufen
Wenn du ein YouTubePlaylistEntry hast, das eine bestimmte Playlist darstellt, kannst du eine YouTubePlaylistVideoFeed abrufen, die YouTubePlaylistVideoEntry-Objekte enthält. Wie oben erläutert, stellen diese Objekte einzelne Videos in einer Playlist dar (mit optionalen benutzerdefinierten Titeln und Beschreibungen). Du kannst diesen Feed abrufen, indem du den URI deiner Playlist an die GetYouTubePlaylistVideoFeed-Methode des YouTubeService-Objekts übergibst:
# a typical playlist URI playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505' playlist_video_feed = yt_service.GetYouTubePlaylistVideoFeed(uri=playlist_uri) # iterate through the feed as you would with any other for playlist_video_entry in playlist_video_feed.entry: print playlist_video_entry.title.text
Playlist hinzufügen
Wenn du eine neue Playlist hinzufügen möchtest, verwende einfach die Methode AddPlaylist des Objekts YouTubeService. Diese Methode nimmt die folgenden Parameter an: „playlist_title“, „playlist_description“ (beides Strings) und ein optionales boolesches Argument, das auf „True“ gesetzt werden kann, wenn die Playlist als privat gekennzeichnet werden soll.
new_public_playlistentry = yt_service.AddPlaylist('my new playlist', 'a new playlist')
if isinstance(new_public_playlistentry, gdata.youtube.YouTubePlaylistEntry):
print 'New playlist added'
# adding a private playlist
new_private_playlistentry = yt_service.AddPlaylist('new private playlist', 'a new private playlist', True)
if isinstance(new_private_playlistentry, gdata.youtube.YouTubePlaylistEntry):
print 'New private playlist added'
Playlist aktualisieren
Verwende die Methode UpdatePlaylist des Objekts YouTubeService, um eine Playlist zu aktualisieren. Die Methode nimmt die folgenden Parameter an: die ID der zu aktualisierenden Playlist, einen neuen Titel, eine neue Beschreibung, einen optionalen booleschen Wert, um die Playlist als privat zu markieren, und einen optionalen String, der den Nutzernamen des Inhabers der Playlist angibt. Standardmäßig wird der aktuell authentifizierte Nutzer verwendet.
# here we are updating a public playlist with a new title while also making it private
# we assume that playlist_to_be_updated here represents a YouTubePlaylistEntry object
playlist_entry_id = playlist_to_be_updated.id.text.split('/')[[]-1]
# we want to keep the original description for the playlist so we store it first
original_description = playlist_to_be_updated.description.text
updated_playlist = yt_service.UpdatePlaylist(playlist_entry_id,
'a new updated title',
original_playlist_description,
playlist_private=True)
Video zur Playlist hinzufügen
Mit der Methode AddPlaylistVideoEntryToPlaylist des Objekts YouTubeService kannst du einer Playlist ein Video hinzufügen. Im folgenden Code wird einer Playlist ein Video mit einem benutzerdefinierten Titel und einer Beschreibung hinzugefügt.
custom_video_title = 'my test video on my test playlist'
custom_video_description = 'this is a test video on my test playlist'
video_id = 'Ncakifd_16k'
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_video_entry = yt_service.AddPlaylistVideoEntryToPlaylist(
playlist_uri, video_id, custom_video_title, custom_video_description)
if isinstance(playlist_video_entry, gdata.youtube.YouTubePlaylistVideoEntry):
print 'Video added'
Hinweis:Ein benutzerdefinierter Titel und eine benutzerdefinierte Beschreibung sind nicht erforderlich. Wenn Sie diese nicht angeben, werden der tatsächliche Titel und die tatsächliche Beschreibung des Videos verwendet.
Videoinformationen in einer Playlist bearbeiten
Verwenden Sie die Methode UpdatePlaylistVideoEntryMetaData des YouTubeService-Objekts, um die Metadaten für eine YouTubePlaylistVideoEntry zu ändern. Im folgenden Beispiel geben wir unserem Video einen neuen benutzerdefinierten Titel und verschieben es an die erste Position (Position 1) in unserer Playlist.
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'
new_video_title = 'a useful video'
new_video_description = 'updated video description'
updated_playlist_video_entry = yt_service.UpdatePlaylistVideoEntryMetaData(
playlist_uri, playlist_entry_id, new_video_title, new_video_description, 1)
Hinweis:Wenn du die Beschreibung und den Titel eines Videos in einer Playlist auf die ursprünglichen Metadaten zurücksetzen möchtest, gib einfach NULL sowohl für den Titel als auch für die Beschreibung ein.
Video aus Playlist entfernen
Wenn du ein Video aus einer Playlist entfernen möchtest, verwende die Methode DeletePlaylistVideoEntry des YouTubeService-Objekts. Für die Methode sind der URI der Playlist, die den zu löschenden Eintrag enthält, sowie die ID des Eintrags erforderlich:
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'
response = yt_service.DeletePlaylistVideoEntry(playlist_uri,
playlist_entry_id)
if response is True:
print 'Entry successfully deleted'
Playlist löschen
Wenn du eine Playlist löschen möchtest, verwende einfach die Methode DeletePlaylist des YouTubeService-Objekts und gib den URI der zu löschenden Playlist an:
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505' response = yt_service.DeletePlaylist(playlist_uri) if response is True: print 'Playlist successfully deleted'
Abos
Wenn du eine Liste der Kanäle, Suchanfragen und Favoriten abrufen möchtest, die ein bestimmter Nutzer abonniert hat, verwende den folgenden URI:
http://gdata.youtube.com/feeds/api/users/username/subscriptions
Hinweis:Alternativ kannst du den String default übergeben, um Favoriten für den aktuell authentifizierten Nutzer abzurufen.
Nutzerabos abrufen
Der folgende Code zeigt, wie die Liste der Abos für einen bestimmten Nutzer abgerufen und gedruckt wird. Abos werden als gdata.youtube.YouTubeSubscriptionFeed dargestellt, die aus gdata.youtube.YouTubeSubscriptionEntry-Objekten bestehen. Wenn du Abos abrufen möchtest, verwende die Methode GetYouTubeSubscriptionFeed des YouTubeService-Objekts und gib entweder den URI eines Abofeeds oder den Nutzernamen ein, dessen Abofeed abgerufen werden soll. Der Standardwert für den Parameter „username“ ist der aktuell authentifizierte Nutzer.
subscription_feed = yt_service.GetYouTubeSubscriptionFeed(username='gdpython')
if isinstance(subscription_feed, gdata.youtube.YouTubeSubscriptionFeed)):
# given a YouTubeSubscriptionEntry we can determine it's type (channel, favorite, or query)
for entry in subscription_feed.entry:
print entry.GetSubscriptionType()
Abo hinzufügen
Du kannst ein neues Abo erstellen, indem du eine neue YouTubeSubsciptionEntry in den Abofeed des authentifizierten Nutzers einfügst. Es gibt drei Arten von Abos: ein Abo für den Kanal eines Nutzers (mit AddSubscriptionToChannel), ein Abo für die Favoriten eines Nutzers (mit AddSubscriptionToFavorites) oder ein Abo für ein bestimmtes Keyword (mit AddSubscriptionToQuery). Mit dem folgenden Code abonniert der authentifizierte Nutzer den Kanal GoogleDevelopers.
new_subscription = yt_service.AddSubscriptionToChannel(
username_to_subscribe_to='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Sie können auch die Favoriten des Nutzers „GoogleDevelopers“ abonnieren:
new_subscription = yt_service.AddSubscriptionToFavorites(
username='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Außerdem können Sie bestimmte Suchbegriffe abonnieren. Hier abonnieren wir eine Suchanfrage nach Videos mit dem Tag „python“.
new_subscription = yt_service.AddSubscriptionToQuery(query='python') if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry): print 'New subscription added'
Abo löschen
Wenn Sie ein Nutzerabo löschen möchten, verwenden Sie die Methode DeleteSubscription des Objekts YouTubeService.
sample_subscription_uri = ('http://gdata.youtube.com/feeds/api/users/'
'gdpython/subscriptions/c0c77ca6102a7479')
response = yt_service.DeleteSubscription(sample_subscription_uri)
if response is True:
print 'Subscription successfully deleted'
Nutzerinteraktion aktivieren
Nutzerprofile
Profil eines Nutzers abrufen
Wenn du das YouTube-Profil eines Nutzers manuell abrufen möchtest, verwende den folgenden URI:
http://gdata.youtube.com/feeds/api/users/username
Sie können ein gdata.youtube.YouTubeUserEntry mit der Methode GetYouTubeUserEntry des YouTubeService-Objekts abrufen.
user_entry = yt_service.GetYouTubeUserEntry(username='gdpython')
# we can then write a helper function to print out the user details
def PrintUserEntry(entry):
# print required fields where we know there will be information
print 'URI: %s\n' % entry.id.text
print 'Age: %s\n' % entry.age.text
print 'Gender: %s\n' % entry.gender.text
print 'Location: %s\n' % entry.location.text
# check if there is information in the other fields and if so print it
if user.first_name:
print 'First Name: %s\n' % user.first_name.text
if user.last_name:
print 'Last Name: %s\n' % user.last_name.text
if user.relationship:
print 'Relationship: %s\n' % user.relationship.text
if user.description:
print 'About me: %s\n' % user.description.text
for link in user.link:
if link.rel == 'related':
print 'Website: %s\n' % link.href
if user.company:
print 'Company: %s\n' % user.company.text
if user.occupation:
print 'Occupation: %s\n' % user.occupation.text
if user.school:
print 'School: %s\n' % user.school.text
if user.hobbies:
print 'Hobbies: %s\n' % user.hobbies.text
if user.movies:
print 'Movies: %s\n' % user.movies.text
if user.music:
print 'Music: %s\n' % user.music.text
if user.books:
print 'Books: %s\n' % user.books.text
if user.hometown:
print 'Hometown: %s\n' % user.hometown.text
Kontakte
Die Kontaktliste eines bestimmten Nutzers kann über die folgende URL abgerufen werden:
http://gdata.youtube.com/feeds/api/users/username/contacts
Nutzerkontakte abrufen
Mit der Methode GetYouTubeContactFeed des Objekts YouTubeService können Sie eine gdata.youtube.YouTubeContactFeed abrufen, die aus gdata.youtube.YouTubeContactEntry-Objekten besteht.
contact_feed = yt_service.GetYouTubeContactFeed(username='GoogleDevelopers')
for entry in contact_feed.entry:
print entry.title.text
# find the apprpriate category element to find out the contact type
for category in entry.category:
if category.scheme == 'http://gdata.youtube.com/schemas/2007/contact.cat':
print category.term
Kontakte hinzufügen
Wenn Sie dem Kontaktfeed eines Nutzers einen neuen Kontakt hinzufügen möchten, verwenden Sie die Methode AddContact des Objekts YouTubeService.
new_contact = yt_service.AddContact(contact_username='GoogleDevelopers') if isinstance(new_contact, gdata.youtube.YouTubeContactEntry) print 'New contact added'
Kontakt annehmen/ablehnen
Verwenden Sie zum Aktualisieren eines Kontakts die Methode UpdateContact des Objekts YouTubeService. Mit dieser Methode können Sie Kontaktanfragen annehmen oder ablehnen und Kontakte als „Freunde“ oder „Familie“ kategorisieren. Im folgenden Beispiel akzeptieren wir einen Kontakt und legen dann die Kategorie „Familie“ fest:
# in this case user 'gdpython' has requested to be our contact
#so the original contact status is 'pending'
updated_contact = yt_service.UpdateContact('gdpython', 'accepted', 'Family')
if isinstance(updated_contact, gdata.youtube.YouTubeContactEntry)
print 'New contact added'
Kontakt löschen
Verwenden Sie die Methode DeleteContact des Objekts YouTubeService, um einen Kontakt zu löschen. Geben Sie dazu den Nutzernamen des Kontakts an, den Sie löschen möchten.
response = yt_service.DeleteContact(contact_username='gdpython') if response is True: print 'Contact deleted'