Mit der YouTube Data API können Client-Anwendungen YouTube-Inhalte in Form von Google Data API-Feeds abrufen und aktualisieren. Ihre Clientanwendung kann die YouTube Data API-Feeds verwenden, um Videos, Kommentare, Antworten, Playlists, Nutzerprofile und Nutzerkontakte abzurufen, zu suchen und zu aktualisieren sowie um Videos zu suchen, die bestimmten Kriterien entsprechen.
Neben einem Hintergrund zu den Funktionen der YouTube Data API enthält dieses Dokument Beispiele für die Interaktion mit der API mithilfe der Python-Clientbibliothek. Zur Verwendung der Python-Clientbibliothek benötigen Sie Python 2.0 oder höher sowie die Elemente Tree, httplib und urllib. Weitere Informationen finden Sie unter Abhängigkeitsmodule.
Wenn Sie Hilfe beim Einrichten der Python-Clientbibliothek benötigen, finden Sie entsprechende Informationen 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 Protokoll für Entwickler.
Informationen zu diesem Dokument
Zielgruppe
Dieses Dokument richtet sich an Programmierer, die Client-Anwendungen schreiben möchten, die über die Python-Clientbibliothek mit YouTube interagieren können. Es enthält eine Reihe von Beispielen für grundlegende Daten-API-Interaktionen.
Referenzinformationen zur YouTube Data API finden Sie im Referenzhandbuch.
In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Ideen des Google Data APIs-Protokolls vertraut sind und wissen, wie man in Python programmiert.
Referenzinformationen zu den Python-Klassen und -Methoden finden Sie unter pyDocs (für die Dienstklasse und Datenklassen), die im Quellcode enthalten sind.
Dokumentstruktur
Diese FAQ sind in folgende Abschnitte gegliedert:
-
Im Abschnitt Authentifizierung werden die zwei verschiedenen Authentifizierungsmethoden beschrieben, die zum Verknüpfen von API-Vorgängen mit einem bestimmten Nutzerkonto zur Verfügung stehen. In diesem Abschnitt werden auch die Unterschiede zwischen der Authentifizierung für die YouTube Data API und anderen Google Data APIs erläutert. In diesem Dokument wird in den Erläuterungen bestimmter API-Funktionen deutlich angegeben, ob die Funktion eine Nutzerauthentifizierung erfordert. Im Allgemeinen müssen alle Anfragen zur Änderung von Video- oder Feeddaten authentifiziert werden. Für schreibgeschützte Anfragen an öffentliche Videos ist keine Authentifizierung erforderlich.
-
Der Abschnitt Videofeeds und -einträge enthält eine Beispiel-API-Antwort und erklärt, wie du Informationen zu einem einzelnen Video aus einer Videoliste oder einer Reihe von Suchergebnissen extrahieren kannst. In diesem Abschnitt wird auch erläutert, wie Sie auf Metadaten zu einem bestimmten Videoeintrag zugreifen können. Zuletzt wird der Mechanismus zum Aktualisieren eines einzelnen Videoeintrags erläutert.
-
Im Abschnitt Videos abrufen und suchen wird erklärt, wie bestimmte Videolisten abgerufen werden können, z. B. ein Standardfeed der beliebtesten Videos auf YouTube. Andere Videolisten umfassen Videos, die von einem bestimmten Nutzer hochgeladen wurden, sowie Videolisten, die sich auf ein bestimmtes Video beziehen. In diesem Abschnitt wird auch erläutert, wie Nutzer mithilfe der API in der Videobibliothek von YouTube nach bestimmten Suchbegriffen oder Kategorien suchen können.
-
Im Abschnitt Videos hochladen werden zwei Möglichkeiten erläutert, wie du Nutzern das Hochladen von Videos aus YouTube über deine Anwendung ermöglichen kannst. Außerdem wird in diesem Abschnitt erklärt, wie du Videos als Antworten auf andere Videos hochlädst.
-
Im Abschnitt Videos aktualisieren und löschen wird beschrieben, wie du mithilfe der API Informationen zu einem YouTube-Video aktualisieren kannst. Außerdem wird beschrieben, wie ein Video über die API entfernt werden kann.
-
Im Abschnitt Community-Funktionen verwenden werden API-Funktionen beschrieben, mit denen Nutzer mit YouTube-Videos interagieren können. Diese Funktionen erklären, wie du ein Video zu einer Bewertung, einem Kommentar oder einer Beschwerde einreichen kannst. Du kannst auch die API verwenden, um Listen mit Videokommentaren abzurufen.
-
Im Abschnitt Videos speichern und erfassen wird erläutert, wie Sie mit der API Ihre Lieblingsvideos, -playlists und Abos für YouTube-Kanäle aufrufen, erstellen und aktualisieren. Außerdem erfahren Sie, wie Sie Playlists und Favoriten ändern, indem Sie Videos hinzufügen oder entfernen.
-
Im Abschnitt Nutzerinteraktion aktivieren wird erläutert, wie Sie Nutzerprofile mit der API abrufen und aktualisieren. In diesem Abschnitt wird auch erläutert, wie Sie Nutzerkontakte abrufen, hinzufügen, aktualisieren und löschen.
Erste Schritte
Voraussetzungen
Deine Clientanwendung kann die YouTube Data API-Feeds zum Suchen, Abrufen und Aktualisieren von Videos, Kommentaren, Antworten, Playlists, Abos und Nutzerprofilen verwenden.Neben einem Hintergrund zu den Funktionen der YouTube Data API enthält dieses Dokument Beispiele für die Interaktion mit der API mithilfe der Python-Clientbibliothek. Zur Verwendung der Python-Clientbibliothek benötigen Sie Python 2.2 und höher sowie die Elemente Tree, httplib und urllib. Weitere Informationen finden Sie unter Abhängigkeitsmodule.
Weitere Informationen zum Konfigurieren 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 Protokoll für Entwickler.
Die folgenden Beispiel-Snippets können kopiert und in den Code eingefügt werden.
Bevor Sie Vorgänge mit der YouTube Data API ausführen können, müssen Sie wie unten gezeigt ein gdata.youtube.service.YouTubeService-Objekt initialisieren. Mit den unten aufgeführten import-Anweisungen werden automatisch weitere Importe aus den Modulen gdata.media und gdata.geo durchgeführt. Beachten Sie, dass für alle Aktionen außer dem Abrufen öffentlicher Inhalte eine Authentifizierung erforderlich ist.
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 dieser Anleitung basieren auf einer Instanz von gdata.youtube.service.YouTubeService. Es kann sinnvoll sein, die nicht authentifizierten Anfragen des interaktiven Python-Interpreters zu testen.
Hinweis: Die Python-Clientbibliothek muss im Pfad korrekt hinzugefügt werden. Installieren Sie sie, indem Sie das bereitgestellte setup.py-Skript ausführen. Weitere Informationen finden Sie im Startleitfaden.
Authentifizierung
Die Python-Clientbibliothek kann für öffentliche oder private Feeds verwendet werden. Öffentliche Feeds sind schreibgeschützt und erfordern keine Authentifizierung. Bei privaten Feeds ist eine Authentifizierung bei den YouTube-Servern erforderlich.
Die Authentifizierung kann über ClientLogin-Authentifizierung (für Desktop-Apps) oder über AuthSub-Authentifizierung (für Webanwendungen) erfolgen.
Entwicklerschlüssel und Client-ID festlegen
Ein Entwicklerschlüssel identifiziert den YouTube-Entwickler, der eine API-Anfrage einreicht. Eine Client-ID identifiziert Ihre Anwendung zu Logging- und Fehlerbehebungszwecken.
Wenn Sie eine API-Anfrage mit der Python-Clientbibliothek stellen, wird der Anfrageheader X-GData-Key verwendet, um den Entwicklerschlüssel anzugeben, und der X-GData-Client-Header, um die Client-ID anzugeben. Der Entwicklerschlüssel und die Client-ID können für das Objekt YouTubeService unabhängig vom verwendeten Authentifizierungsschema festgelegt werden:
yt_service.developer_key = 'ABCxyz123...' yt_service.client_id = 'My-Client_id'
Sie müssen sich für einen YouTube-Entwicklerschlüssel registrieren.
AuthSub-Authentifizierung für Webanwendungen
Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer für YouTube-/Google-Konten authentifizieren müssen. Der Operator benötigt für den YouTube-Nutzer keinen Zugriff auf den Nutzernamen und das Passwort – es sind nur spezielle AuthSub-Tokens erforderlich.
Wenn der Nutzer Ihre Anwendung zum ersten Mal besucht, ist er noch nicht bei Google-Diensten authentifiziert. In diesem Fall müssen Sie dem Nutzer einen Link zur Verfügung stellen, über den der Nutzer zu Google weitergeleitet wird, um die Zugriffsanfrage für Ihr 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 des Dienstobjekts gesendet werden:
- Weiter: Die URL der Seite, zu der YouTube den Nutzer weiterleiten soll, nachdem er deine App für den Zugriff auf sein Konto autorisiert hat.
- scope: Gibt an, dass die Anwendung nur auf YouTube API-Feeds zugreift.
- secure – Gibt an, dass das zurückgegebene Token kein sicheres Token ist.
- session (Sitzung): Gibt an, dass dieses Token gegen ein Mehrzwecktoken (Sitzung) ausgetauscht 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 auf den Link klicken, um sich in seinem YouTube-Konto anzumelden. Nachdem der Nutzer Ihre Anwendung für den Zugriff auf sein Konto autorisiert hat, wird er wieder zur next-URL weitergeleitet. An die URL wird ein Einmal-Tokenwert als Suchparameter angehängt. Die URL sieht ungefähr so aus:
http://www.example.com/video_upload.pyc?token=Abc123...
Im nächsten Abschnitt wird gezeigt, wie Sie dieses Token upgraden. Das folgende Snippet zeigt eine der Möglichkeiten, dieses Token von der URL abzurufen:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters[[]'token' ]
Upgrade auf ein Sitzungstoken ausführen
Aus Sicherheitsgründen ist dieses Token nur einmal verwendbar. Daher müssen Sie es jetzt 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 steht für ein Einmal-AuthSub-Token. Da session = True oben angegeben wurde, kann dieses Token mit der Methode UpgradeToSessionToken gegen ein AuthSub-Sitzungstoken ausgetauscht werden. Dadurch wird der Dienst AuthSubSessionToken aufgerufen.
Dein YouTubeService-Objekt ist jetzt vollständig authentifiziert und kann für alle weiteren Anfragen mit der YouTube API verwendet werden. AuthSub-Sitzungstokens laufen nur ab, wenn Sie ausdrücklich eine Anfrage zum Widerrufen senden oder der Nutzer den Zugriff über die Seite Autorisierte Websites in seinem YouTube-Konto widerrufen möchte.
ClientLogin-Authentifizierung für installierte Anwendungen
Die ClientLogin-Authentifizierung wird in installierten Anwendungen verwendet, die Ihren Nutzer speichern und nach seinem Nutzernamen und Passwort fragen können. Um diese Form der Authentifizierung zu verwenden, rufen Sie die ProgrammaticLogin-Methode von YouTubeService auf, die von der gdata.service.GDataService-Klasse übernommen wurde, und geben Sie die ID und das Passwort des Nutzers an, in dessen Client Ihr Client die Anfrage zur Authentifizierung 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 zur Verarbeitung aller weiteren Anfragen verwendet werden. Wenn du Uploads und andere Schreibanfragen (Kommentare hinzufügen usw.) für die YouTube API ausführen möchtest, achte bei der Authentifizierung darauf, dass du deinen Entwicklerschlüssel und deine Client-ID an das yt_service-Objekt übergibst:
# 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 YouTubeService-Objekt legt automatisch die richtigen Header für X-GData-Key und X-GData-Client fest, wenn die Attribute developer_key und client_id festgelegt sind.
Hinweis: Weitere Informationen zu AuthSub und ClientLogin finden Sie in der Authentifizierungsdokumentation für Google Data APIs.
Videofeeds und -einträge
Die YouTube Data API bietet mehrere Videofeeds, die Listen mit Videos enthalten, darunter Standardfeeds, Uploads, Abos und Favoriten. Die URL für die einzelnen Feeds ist im Referenzhandbuch dokumentiert.
Feed von Videos anzeigen
Viele Feeds in der YouTube API bestehen aus Videoeinträgen. Diese Feeds lassen sich am einfachsten als gdata.youtube.YouTubeVideoFeed-Objekte modellieren, die jeweils eine Anzahl 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 einzelnen Einträge zu verarbeiten, ähnlich wie im folgenden Code:
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 Bereich Videos abrufen und suchen findest du Informationen zu häufigen Feed-URLs und dazu, wie du verschiedene Videofeeds abrufen kannst.
Bestimmten Videoeintrag abrufen
Wenn Sie die Video-ID kennen, können Sie nur die Informationen für einen bestimmten Videoeintrag abrufen. Die URL des Eintrags basiert auf der Video-ID:
http://gdata.youtube.com/feeds/api/videos/videoID
Mit dem folgenden Code wird ein gdata.youtube.YouTubeVideoEntry abgerufen, der einem Video auf YouTube entspricht:
entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')
Videoeintragsinhalte
Es gibt viele Metadaten, die aus einem gdata.youtube.YouTubeVideoEntry-Objekt abgerufen werden können, z. B. Thumbnails, Player-URLs und Videodauer. Der folgende Code zeigt, wie Sie auf einige dieser Informationen zugreifen können. Die Python-Clientbibliothek abstrahiert die meisten dieser Funktionen durch die Zuordnung von XML-Elementen zu Klassen. Die wichtigsten Informationen zu einem YouTubeVideoEntry-Eintrag finden Sie in den untergeordneten Elementen des Attributs media (mit einem gdata.media.Group-Objekt) im Eintrag (für das XML-media:group-Element). Hier ein Beispiel für das Abrufen von Video-Metadaten:
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 der beliebtesten Videos auf YouTube. Bisher wurden von der API andere Standardfeeds unterstützt, die inzwischen eingestellt wurden. Weitere Informationen finden Sie im Entwicklerhandbuch.
Die URL für den Feed der beliebtesten Videos auf YouTube hat das folgende Format:
http://gdata.youtube.com/feeds/api/standardfeeds/most_popular
Hinweis:Sie können auch gebietsspezifische Standardfeeds abrufen. Geben Sie dazu eine localeID im folgenden Format an: http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. Die beliebtesten Videos in Japan sind beispielsweise: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. Eine vollständige Liste der mutmaßlichen localeIDs 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))
Videos abrufen, die von einem bestimmten Nutzer hochgeladen wurden
Jeder YouTube-Nutzer hat unter http://gdata.youtube.com/feeds/api/users/username/uploads einen Videofeed, der den hochgeladenen Videos entspricht.
Der folgende Code zeigt, wie ein Feed für Uploads von Nutzern 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 anstelle von username auch den String „Standard“ verwenden, um Videos für den aktuell authentifizierten Nutzer abzurufen.
Ähnliche Videos abrufen
Übergeben Sie die Video-ID des gdata.youtube.YouTubeVideoEntry-Objekts an die GetYouTubeRelatedVideoFeed-Methode des gdata.youtube.service.YouTubeService-Objekts, um ähnliche Videos abzurufen. Dadurch wird ein YouTubeVideoFeed-Objekt abgerufen, das zugehörige Einträge enthält.
related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')
Videos suchen
Mit der YouTube Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von Videoeinträgen, die von einem bestimmten Autor veröffentlicht wurden, nach Videoformat oder nach einem bestimmten Suchbegriff. Dazu erstellen Sie ein gdata.service.YouTubeVideoQuery-Objekt mit Ihren spezifischen Suchkriterien und übergeben es an die Methode YouTubeQuery von gdata.youtube.service.YouTubeService.
Das folgende Beispiel zeigt, wie eine Suchanfrage ausgeführt wird, wobei die Ergebnisse nach der Anzahl der Aufrufe geordnet sind, einschließlich eingeschränkter Videos (von 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 die abgeleiteten Klassen wie YouTubeVideoQuery sind für das Erstellen von Feed-URLs verantwortlich. Mit dem oben gezeigten VideoQuery wird eine URL erstellt, die der folgenden entspricht:
http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount
Hier sind einige der gängigsten YouTubeVideoQuery-Properties zum Festlegen von Suchparametern:
author- Legt den Autor des Eintrags fest. Autor ist gleichbedeutend mit YouTube-Nutzername.
format- Gibt das Videoformat an. Akzeptiert numerische Parameter zur Angabe einer von zwei RTSP-Streaming-URLs für die Videowiedergabe auf Mobilgeräten oder einer HTTP-URL für den einbettbaren Flash-Player
racy- Gibt an, ob eingeschränkte Inhalte in den Ergebnissen enthalten sein sollen. Zulässig sind nur die Parameter „include“ und „exclude“.
max_results- Bestimmt die maximale Anzahl gleichzeitig zurückgegebener Einträge.
start_index- Legt den 1-basierten Index des ersten abzurufenden Ergebnisses fest (für das Paging).
orderby- Bestimmt die Reihenfolge, in der Einträge aufgelistet werden, z. B. nach
relevance,viewCount,publishedoderrating. time- Legt einen Zeitraum fest, um die Ergebnisse des Standardfeeds auf
today,this_week,this_monthoderall_timezu beschränken. vq- Legt einen Suchbegriff fest. Sucht in allen Videometadaten wie Titel, Tags und Beschreibungen nach dem angegebenen String.
Hinweis: Weitere Informationen zu Abfrageparametern finden Sie im Referenzhandbuch für die YouTube Data API und im Referenzhandbuch für die Google Data APIs.
Mit Kategorien und Suchbegriffen suchen
Du kannst die Suchergebnisse so einschränken, dass nur Videos angezeigt werden, die bestimmten Kategorien und Keywords entsprechen. Im Referenzhandbuch wird beschrieben, wie Sie vordefinierte YouTube-Kategorien wie Musik, Personen und Blogs sowie benutzerdefinierte Keywords (Tags) festlegen.
Der folgende Code zeigt, wie Sie mit Suchbegriffen (Tags) suchen, indem Sie die Suchbegriffe in Kleinschreibung ändern. Hinweis: Da einige Wörter (z. B. "Comedy") sowohl eine YouTube-Kategorie als auch ein Keyword sein können, beziehen sich Suchanfragen auf Kategorie- und Keyword-Ebene auf die Konvention, dass ein Wort in Großbuchstaben ("Comedy") eine YouTube-Kategorie bezeichnet, während ein Kleinbuchstabe ("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)
Anhand von Entwickler-Tags suchen
Entwickler-Tags sind zusätzliche, versteckte Keywords, mit denen Entwickler Inhalte kennzeichnen können, die Endnutzer in ihrer App hochgeladen haben. Entwickler-Tags werden mit dem Entwicklerschlüssel abgeglichen, der während des Uploads in den Headern festgelegt ist. Diese Keywords sind nicht öffentlich sichtbar und können zum Abrufen von Videos verwendet werden. Wenn Sie nach Videos mit einem bestimmten Entwickler-Tag suchen möchten, senden Sie eine allgemeine YouTube Data API-Suchanfrage mit Ihrem Entwicklerschlüssel. Gib unbedingt das Kategorieschema und das Entwickler-Tag an, mit dem Videos übereinstimmen müssen. Über die unten stehende URL können Sie einen Feed mit Videos abrufen, die zu Ihrem Entwickler-Tag passen (in unserem Beispiel Ihr_tag_here).
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
Einen allgemeinen Überblick über den Uploadvorgang finden Sie in den Diagrammen im Protokollleitfaden. Sie haben zwei Möglichkeiten, Videos hochzuladen:
- Entweder durch Hochladen des Videos direkt von Ihren Servern über die Direktupload-Methode
- oder zuerst die Metadaten senden und dann den Nutzer bitten, das Video über die browserbasierte Uploadmethode direkt auf YouTube hochzuladen.
Direkter Upload
Um ein Video hochzuladen, musst du zuerst ein neues gdata.youtube.YouTubeVideoEntry-Objekt erstellen und ihm ein gdata.media.Group-Objekt übergeben, das die erforderlichen Metadaten enthält. Im folgenden Beispiel wird das Quicktime-Video „mytestmovie.mov“ mit den folgenden Eigenschaften auf YouTube hochgeladen:
| Attribut | Wert |
|---|---|
| Title | Mein Testfilm |
| Kategorie | Automatisch |
| Keywords | Autos, lustig |
| Beschreibung | Meine Beschreibung |
| Dateiname | mytestmovie.mov |
| MIME-Typ der Datei | video/quicktime |
| Privatsphäre? | falsch |
| Aufnahmeort | 37,-122 (lat,long) |
| Entwickler-Tags | mydevelopertag, anotherdevelopertag |
Mit dem Code unten wird eine leere YouTubeVideoEntry erstellt, die hochgeladen werden kann. Für die Methode InsertVideoEntry in YouTubeService sind die folgenden Parameter erforderlich:
video_entry: Dasgdata.youtube.VideoEntry-Objekt, das Metadaten enthältfilename_or_handle: ein dateiähnliches Objekt oder der Dateiname, aus dem das Video gelesen wirdyoutube_username: Ein optionaler String, der den Nutzernamen für das Konto angibt, in das dieses Video hochgeladen werden soll. Natürlich benötigt Ihr Konto die entsprechenden Berechtigungen. Standardmäßig wird das aktuell authentifizierte Nutzerkonto verwendet.content_type: Ein optionaler String, der den MIME-Typ des hochzuladenden Videos angibt.
yt_service auf ein vollständig authentifiziertes YouTubeService-Objekt verweist.
# 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 versehen möchten (weitere Informationen findest du unter Nach Entwickler-Tags suchen), hätten wir die AddDeveloperTags-Methode verwenden können, bevor du InsertVideoEntry aufgerufen hast:
developer_tags = [[]'some_tag_01', 'another_tag'] video_entry.AddDeveloperTags(developer_tags)
Hinweis: Damit Videos als privat hochgeladen werden können, muss ein privates Attribut an gdata.media.Group ü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 erfolgt fast gleich wie der direkte Upload, mit der Ausnahme, dass das Dateibinär nicht in derselben Anfrage hochgeladen wird, die Sie zum Senden der Metadaten des Videos verwenden. Stattdessen erstellen Sie eine YouTubeVideoEntry, die nur Metadaten enthält. Dieser Videoeintrag wird dann in einem speziellen Link auf dem YouTube API-Server gepostet. Die XML-Antwort enthält eine token und eine url, mit denen dann die Binärdatei unter Verwendung eines Standard-HTML-Formulars 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 Code oben druckt einen Link und ein Token aus, mit dem ein HTML-Formular erstellt wird, das im Browser des Nutzers angezeigt wird. Unten sehen Sie ein einfaches Beispielformular, in dem youtube_token den Inhalt des zurückgegebenen Tokenelements darstellt, wie er oben aus YouTubeVideoEntry abgerufen wird. Damit der Nutzer nach dem Senden des Formulars auf deine Website weitergeleitet werden kann, musst du einen next-Parameter an post_url anhängen (siehe unten). Er funktioniert auf dieselbe Weise wie der next-Parameter eines AuthSub-Links. Der einzige Unterschied ist, dass hier anstelle eines Einweg-Tokens 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)
Die Antwort auf 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 wird es sofort im Uploadfeed eines authentifizierten Nutzers angezeigt. Sie wird jedoch erst auf der Website veröffentlicht, wenn sie verarbeitet wurde. Videos, die abgelehnt oder nicht hochgeladen wurden, sind nur im Uploadfeed des authentifizierten Nutzers zu sehen. Mit dem folgenden Code wird der Status einer YouTubeVideoEntry geprüft, um festzustellen, ob sie noch nicht aktiv ist 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 werden aktualisiert
Wenn Sie Metadaten zu Videos aktualisieren möchten, aktualisieren Sie einfach das Objekt YouTubeVideoEntry und verwenden dann die Methode UpdateVideoEntry des YouTubeService-Objekts. Diese Methode verwendet als Parameter einen YouTubeVideoEntry, der aktualisierte Metadaten enthält.
# 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 sehr einfach und erfordert lediglich einen Aufruf der DeleteVideoEntry des YouTubeService-Objekts.
response = yt_service.DeleteVideoEntry(entry_to_be_deleted) if response: print 'Video successfully deleted!'
Community-Funktionen verwenden
Bewertung hinzufügen
Verwenden Sie zum Bewerten eines Videos die Methode AddRating des YouTubeService-Objekts. Du kannst deine eigenen Videos nicht bewerten. Die Bewertungen müssen zwischen 1 und 5 (einschließlich) 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 für ein Video abrufen
Mit einem YouTubeVideoEntry-Objekt oder einer einfachen Video-ID kannst du einen Feed mit den Kommentaren für das Video mithilfe der Methode GetYouTubeVideoCommentFeed des YouTubeService-Objekts 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 die Methode AddComment des Objekts YouTubeService. Die Methode erfordert ein vollständiges YouTubeVideoEntry-Objekt, das kommentiert werden muss, sowie einen 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 einem zweiten Video zugeordnet wurde. Die Funktion für Videoantworten wurde wie in dieser Mitteilung beschrieben eingestellt. Vorhandene Videoantworten sind zwar weiterhin verfügbar, YouTube kann aber keine Liste mit Videoantworten für ein Video mehr abrufen, keine neuen Videoantworten hochladen und keine Videoantworten mehr löschen. Du hast allerdings die Möglichkeit, das in einer Videoantwort verwendete Video zu löschen. 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.
- Eine Anfrage zum Hinzufügen einer Videoantwort gibt einen 403-HTTP-Antwortcode zurück.
- Eine Anfrage zum Löschen einer Videoantwort gibt den HTTP-Antwortcode 403 zurück.
Melden eines Videos
Eine Beschwerde zu einem Video wird über die Methode AddComplaint des YouTubeService-Objekts hinzugefügt. Der Beschwerdebegriff muss eine gültige Kategorie sein. Weitere Informationen finden Sie im Abschnitt Hinzufügen einer Beschwerde im Protokollleitfaden.
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)
Speichern und Sammeln von Videos
Gespeicherte Videos
Lieblingsvideos eines Nutzers abrufen
YouTube-Nutzer können Videos, die sie sich ansehen, als Favoriten markieren. Der allgemeine Speicherort für den Lieblingsfeed eines Nutzers ist die folgende URL.
http://gdata.youtube.com/feeds/api/users/username/favorites
Mit der Methode GetUserFavoritesFeed des YouTubeService-Objekts können Sie die Lieblingsvideos eines Nutzers abrufen. Die Methode verwendet einen optionalen String als Parameter für den YouTube-Nutzernamen des Nutzers, dessen bevorzugter Feed abgerufen werden soll.
favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')
Der zurückgegebene Feed ist ein regulärer Videofeed mit YouTubeVideoEntry-Objekten.
Hinweis: Sie können auch den String default übergeben, um Favoriten für den aktuell authentifizierten Nutzer abzurufen. Dies ist die Standardeinstellung der Methode GetUserFavoritesFeed, wenn kein Nutzername angegeben ist.
Favoriten hinzufügen
Verwenden Sie die Methode AddVideoEntryToFavorites des YouTubeService-Objekts, um ein Lieblingsvideo hinzuzufügen. Die Parameter sind der YouTubeVideoEntry, der hinzugefügt werden soll, und optional der Nutzername, dem die Favoriten hinzugefügt werden sollen (Standard ist 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 vom Nutzer erstellten Playlists enthält. Jede Playlist hat dann einen Feed für alle Videos.
Nutzerplaylists werden abgerufen
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 YouTubeService-Objekts 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:Statt einen bestimmten Nutzernamen zu übergeben (z. B. „gdpython“ im Beispiel oben), können Sie auch den String 'default' übergeben, um auf den aktuell authentifizierten Nutzer zu verweisen.
Ein gdata.youtube.YouTubePlaylistFeed steht für einen Feed mit gdata.youtube.YouTubePlaylistEntry-Objekten. Sie beziehen sich auf einzelne Playlists eines Nutzers. Videoeinträge in einer bestimmten Playlist werden als gdata.youtube.YouTubePlaylistVideoEntry-Objekte dargestellt. Diese Objekte ähneln bis auf wenige Ausnahmen den normalen gdata.youtube.YouTubeVideoEntry-Objekten. Benutzerdefinierte Titel und Beschreibungen können auf die Videos angewendet werden. Ein Positionsfeld gibt an, wo das Video in der Playlist erscheint.
Playlist-Informationen abrufen
Mit einem YouTubePlaylistEntry (für eine bestimmte Playlist) kannst du ein YouTubePlaylistVideoFeed abrufen, das YouTubePlaylistVideoEntry-Objekte enthält. Wie oben erläutert, stellen diese Objekte einzelne Videos in einer Playlist dar (mit optionalen benutzerdefinierten Titeln und Beschreibungen). Sie erhalten diesen Feed, indem Sie den URI Ihrer Playlist an die Methode GetYouTubePlaylistVideoFeed des YouTubeService-Objekts übergeben:
# 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 YouTubeService-Objekts. Für diese Methode werden die folgenden Parameter verwendet: „playlist_title“, „playlist_description“ (beide Strings) und ein optionaler boolescher Wert, der auf True gesetzt werden kann, wenn die Playlist als privat markiert 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 YouTubeService-Objekts, um eine Playlist zu aktualisieren. Die Methode verwendet die folgenden Parameter: die ID der zu aktualisierenden Playlist, einen neuen Titel, eine neue Beschreibung, einen optionalen booleschen Wert zur Markierung der Playlist als privat und einen optionalen String für den Nutzernamen, der der Playlist gehört. Als String wird standardmäßig 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)
Videos zur Playlist hinzufügen
Mit der Methode AddPlaylistVideoEntryToPlaylist des Objekts YouTubeService kannst du ein Video zu einer Playlist hinzufügen. Mit dem Code unten kannst du einer Playlist ein Video mit einem benutzerdefinierten Titel und einer Beschreibung hinzufügen.
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 Beschreibung sind nicht erforderlich. Wenn diese nicht angegeben sind, wird der tatsächliche Titel und die tatsächliche Beschreibung des Videos verwendet.
Videoinformationen zur Playlist bearbeiten
Verwenden Sie die Methode UpdatePlaylistVideoEntryMetaData des YouTubeService-Objekts, um die Metadaten für ein YouTubePlaylistVideoEntry zu ändern. Im folgenden Beispiel geben wir unserem Video einen neuen benutzerdefinierten Titel und verschieben ihn an die erste Position (Position 1) der 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 wiederherstellen möchtest, gib einfach NULL für Titel und Beschreibung ein.
Video aus Playlist entfernen
Wenn du ein Video aus einer Playlist entfernen möchtest, verwende die Methode DeletePlaylistVideoEntry des YouTubeService-Objekts. Die Methode erfordert den URI der Playlist, die den zu löschenden Eintrag enthält, sowie die ID des Eintrags:
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 übergib dem URI der zu löschenden Playlist:
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
Verwenden Sie den folgenden URI, um eine Liste der Kanäle, Suchanfragen und Favoriten abzurufen, die ein bestimmter Nutzer abonniert hat:
http://gdata.youtube.com/feeds/api/users/username/subscriptions
Hinweis: Sie können auch den String default übergeben, um Favoriten für den aktuell authentifizierten Nutzer abzurufen.
Nutzerabos abrufen
Der folgende Code zeigt, wie die Liste der Abos eines bestimmten Nutzers abgerufen und gedruckt wird. Abos werden als gdata.youtube.YouTubeSubscriptionFeed dargestellt, die aus gdata.youtube.YouTubeSubscriptionEntry-Objekten besteht. Verwenden Sie zum Abrufen von Abos die Methode GetYouTubeSubscriptionFeed des YouTubeService-Objekts und übergeben Sie entweder den URI eines Abofeeds oder den Nutzernamen, dessen Abofeed abgerufen werden soll. Der Nutzername ist standardmäßig auf den aktuell authentifizierten Nutzer festgelegt.
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 ein neues YouTubeSubsciptionEntry in den Abofeed des authentifizierten Nutzers einfügst. Wir können drei Arten von Abos erstellen: 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). Der folgende Code abonniert den authentifizierten Nutzer für 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 haben Sie die Möglichkeit, bestimmte Suchbegriffe zu abonnieren. Hier abonnieren wir eine Abfrage für 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
Verwenden Sie zum Löschen eines Nutzerabos die Methode DeleteSubscription des YouTubeService-Objekts.
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
Nutzerprofil abrufen
Wenn Sie das YouTube-Profil eines Nutzers manuell abrufen möchten, verwenden Sie den folgenden URI:
http://gdata.youtube.com/feeds/api/users/username
Sie können einen 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 Liste der Kontakte eines bestimmten Nutzers kann über die folgende URL abgerufen werden:
http://gdata.youtube.com/feeds/api/users/username/contacts
Nutzerkontakte werden abgerufen
Mit der Methode GetYouTubeContactFeed des YouTubeService-Objekts kann ein gdata.youtube.YouTubeContactFeed mit gdata.youtube.YouTubeContactEntry-Objekten abgerufen werden.
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
Verwenden Sie die Methode AddContact des YouTubeService-Objekts, um einem Kontaktkontakt eines Nutzers einen neuen Kontakt hinzuzufügen.
new_contact = yt_service.AddContact(contact_username='GoogleDevelopers') if isinstance(new_contact, gdata.youtube.YouTubeContactEntry) print 'New contact added'
Annehmen/Ablehnen eines Kontakts
Verwenden Sie zum Aktualisieren eines Kontakts die Methode UpdateContact des YouTubeService-Objekts. Diese Methode kann verwendet werden, um Kontaktanfragen anzunehmen oder abzulehnen sowie Kontakte als „Freund“ oder „Familie“ zu kategorisieren. Im folgenden Beispiel akzeptieren wir einen Kontakt und legen dann seine Kategorie auf "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 zum Löschen eines Kontakts die Methode DeleteContact des YouTubeService-Objekts und übergeben Sie den Nutzernamen des zu löschenden Kontakts.
response = yt_service.DeleteContact(contact_username='gdpython') if response is True: print 'Contact deleted'