Интеграция API Spotify с Python: полное руководство для разработчиков

python --version

# Создание виртуального окружения
python -m venv spotify_env

# Активация на Windows
spotify_env\Scripts\activate

# Активация на macOS/Linux
source spotify_env/bin/activate

pip install requests spotipy python-dotenv

SPOTIFY_CLIENT_ID=your_client_id
SPOTIFY_CLIENT_SECRET=your_client_secret
SPOTIFY_REDIRECT_URI=your_redirect_uri

SPOTIFY_CLIENT_ID=your_client_id_here
SPOTIFY_CLIENT_SECRET=your_client_secret_here
SPOTIFY_REDIRECT_URI=http://localhost:8888/callback

import base64
import requests
import json
import os
from dotenv import load_dotenv

load_dotenv()

client_id = os.getenv("SPOTIFY_CLIENT_ID")
client_secret = os.getenv("SPOTIFY_CLIENT_SECRET")

# Кодирование client_id и client_secret в base64
credentials = f"{client_id}:{client_secret}"
encoded_credentials = base64.b64encode(credentials.encode()).decode()

# Запрос токена доступа
auth_url = "https://accounts.spotify.com/api/token"
headers = {
"Authorization": f"Basic {encoded_credentials}",
"Content-Type": "application/x-www-form-urlencoded"
}
data = {"grant_type": "client_credentials"}

response = requests.post(auth_url, headers=headers, data=data)
token_data = response.json()
access_token = token_data.get("access_token")

print(f"Получен токен доступа: {access_token[:10]}...")

pip install spotipy

import spotipy
from spotipy.oauth2 import SpotifyClientCredentials
import os
from dotenv import load_dotenv

load_dotenv()

client_id = os.getenv("SPOTIFY_CLIENT_ID")
client_secret = os.getenv("SPOTIFY_CLIENT_SECRET")

# Настройка менеджера учетных данных
auth_manager = SpotifyClientCredentials(
client_id=client_id,
client_secret=client_secret
)

# Создание экземпляра Spotipy с аутентификацией
sp = spotipy.Spotify(auth_manager=auth_manager)

# Пробный запрос – поиск трека
results = sp.search(q='artist:Arctic Monkeys track:505', type='track')
for track in results['tracks']['items']:
print(f"Найден трек: {track['name']} от {track['artists'][0]['name']}")

import spotipy
from spotipy.oauth2 import SpotifyOAuth
import os
from dotenv import load_dotenv

load_dotenv()

client_id = os.getenv("SPOTIFY_CLIENT_ID")
client_secret = os.getenv("SPOTIFY_CLIENT_SECRET")
redirect_uri = os.getenv("SPOTIFY_REDIRECT_URI")

# Настройка OAuth менеджера с нужными scopes
scope = "user-read-recently-played user-top-read user-library-read"
auth_manager = SpotifyOAuth(
client_id=client_id,
client_secret=client_secret,
redirect_uri=redirect_uri,
scope=scope
)

# Создание экземпляра Spotipy с OAuth
sp = spotipy.Spotify(auth_manager=auth_manager)

# Получение информации о текущем пользователе
user_info = sp.current_user()
print(f"Вход выполнен как: {user_info['display_name']}")

# Получение недавно прослушанных треков
recent_tracks = sp.current_user_recently_played(limit=5)
for item in recent_tracks['items']:
track = item['track']
print(f"{track['name']} – {track['artists'][0]['name']}")

import pandas as pd
import spotipy
from spotipy.oauth2 import SpotifyClientCredentials
import os
from dotenv import load_dotenv

load_dotenv()

client_id = os.getenv("SPOTIFY_CLIENT_ID")
client_secret = os.getenv("SPOTIFY_CLIENT_SECRET")

# Настройка Spotipy
sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(
client_id=client_id, 
client_secret=client_secret
))

# Список ID треков для анализа
track_ids = [
'4cOdK2wGLETKBW3PvgPWqT', # Arctic Monkeys – 505
'0ct6r3EGTcMLPtrXHDvVjc', # The Weeknd – The Hills
'6DCZcSspjsKoFjzjrWoCdn' # Ed Sheeran – Perfect
]

# Получение аудио-характеристик треков
audio_features = sp.audio_features(track_ids)

# Получение метаданных треков
tracks_data = []
for track_id in track_ids:
track_info = sp.track(track_id)

# Извлечение нужных полей
track_data = {
'id': track_id,
'name': track_info['name'],
'artist': track_info['artists'][0]['name'],
'album': track_info['album']['name'],
'release_date': track_info['album']['release_date'],
'popularity': track_info['popularity'],
'duration_ms': track_info['duration_ms']
}
tracks_data.append(track_data)

# Создание DataFrame для удобного анализа
tracks_df = pd.DataFrame(tracks_data)
features_df = pd.DataFrame(audio_features)

# Объединение данных
combined_df = pd.merge(tracks_df, features_df, on='id')
print(combined_df[['name', 'artist', 'popularity', 'danceability', 'energy', 'tempo']])

# ID плейлиста Spotify (часть URL после 'playlist/')
playlist_id = '37i9dQZEVXbMDoHDwVN2tF' # Global Top 50

# Получение информации о плейлисте
playlist = sp.playlist(playlist_id)
print(f"Анализируем плейлист: {playlist['name']} (треков: {playlist['tracks']['total']})")

# Извлечение всех треков из плейлиста с учетом пагинации
tracks = []
results = playlist['tracks']

while results:
tracks.extend(results['items'])
if results['next']:
results = sp.next(results)
else:
results = None

# Формируем список ID треков для анализа
playlist_track_ids = [item['track']['id'] for item in tracks if item['track']['id']]

# Получаем аудио-характеристики (максимум 100 за один запрос)
audio_features_list = []
for i in range(0, len(playlist_track_ids), 100):
chunk = playlist_track_ids[i:i+100]
audio_features_list.extend(sp.audio_features(chunk))

# Создаем таблицу с характеристиками
audio_df = pd.DataFrame(audio_features_list)

# Рассчитываем средние характеристики плейлиста
avg_features = audio_df[['danceability', 'energy', 'valence', 'tempo', 'acousticness']].mean()
print("\nСредние характеристики плейлиста:")
print(avg_features)

# Поиск артиста
artist_name = "Coldplay"
results = sp.search(q=artist_name, type='artist', limit=1)

if results['artists']['items']:
artist = results['artists']['items'][0]
artist_id = artist['id']
print(f"Найден артист: {artist['name']} (популярность: {artist['popularity']})")

# Получение популярных треков артиста
top_tracks = sp.artist_top_tracks(artist_id)

print("\nПопулярные треки:")
for i, track in enumerate(top_tracks['tracks'][:5], 1):
print(f"{i}. {track['name']} – {track['album']['name']}")

# Получение похожих артистов
related = sp.artist_related_artists(artist_id)

print("\nПохожие артисты:")
for i, similar_artist in enumerate(related['artists'][:5], 1):
print(f"{i}. {similar_artist['name']} (популярность: {similar_artist['popularity']})")

# Получение всех альбомов
albums = []
results = sp.artist_albums(artist_id, album_type='album', limit=50)

while results:
albums.extend(results['items'])
if results['next']:
results = sp.next(results)
else:
results = None

unique_albums = {}
for album in albums:
# Избегаем дубликатов (делюкс-издания и т.д.)
name = album['name'].lower()
if name not in unique_albums:
unique_albums[name] = album

print(f"\nУникальных альбомов: {len(unique_albums)}")

# Анализ выпуска альбомов по годам
album_years = [album['release_date'][:4] for album in unique_albums.values() 
if album['release_date'] and len(album['release_date']) >= 4]

year_counts = pd.Series(album_years).value_counts().sort_index()
print("\nРаспределение альбомов по годам:")
print(year_counts)

import spotipy
from spotipy.oauth2 import SpotifyOAuth
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics.pairwise import cosine_similarity
import os
from dotenv import load_dotenv

load_dotenv()

# Настройка аутентификации с нужными scope
scope = "user-top-read playlist-modify-private user-library-read"
sp = spotipy.Spotify(auth_manager=SpotifyOAuth(
client_id=os.getenv("SPOTIFY_CLIENT_ID"),
client_secret=os.getenv("SPOTIFY_CLIENT_SECRET"),
redirect_uri=os.getenv("SPOTIFY_REDIRECT_URI"),
scope=scope
))

# Получение любимых треков пользователя
top_tracks = sp.current_user_top_tracks(limit=50, time_range='medium_term')
top_track_ids = [track['id'] for track in top_tracks['items']]

# Получение аудио-характеристик этих треков
audio_features = sp.audio_features(top_track_ids)

# Создаем DataFrame для анализа
features_df = pd.DataFrame(audio_features)

# Выбираем важные характеристики для анализа
feature_cols = ['danceability', 'energy', 'valence', 'tempo', 'acousticness', 'instrumentalness']

# Нормализуем данные для корректного сравнения
scaler = MinMaxScaler()
normalized_features = scaler.fit_transform(features_df[feature_cols])

# Вычисляем "центр вкуса" – средние значения характеристик
taste_profile = normalized_features.mean(axis=0).reshape(1, -1)

# Поиск треков со схожими характеристиками
# Используем несколько жанров для разнообразия
seed_genres = ['pop', 'rock', 'indie', 'electronic', 'hip-hop']
recommendations = sp.recommendations(
seed_genres=seed_genres,
limit=100,
target_danceability=features_df['danceability'].mean(),
target_energy=features_df['energy'].mean(),
target_valence=features_df['valence'].mean(),
target_acousticness=features_df['acousticness'].mean()
)

# Извлекаем ID рекомендованных треков
recommended_track_ids = [track['id'] for track in recommendations['tracks']]

# Получаем их аудио-характеристики
rec_audio_features = sp.audio_features(recommended_track_ids)
rec_features_df = pd.DataFrame(rec_audio_features)

# Нормализуем для сравнения
rec_normalized = scaler.transform(rec_features_df[feature_cols])

# Вычисляем схожесть с профилем вкуса
similarities = cosine_similarity(rec_normalized, taste_profile)
rec_features_df['similarity'] = similarities

# Сортируем по схожести
rec_features_df['track_id'] = recommended_track_ids
sorted_recommendations = rec_features_df.sort_values('similarity', ascending=False)

# Выбираем 20 наиболее подходящих треков
best_matches = sorted_recommendations.head(20)['track_id'].tolist()

# Создаем новый плейлист для пользователя
user_id = sp.current_user()['id']
playlist_name = "Ваш персонализированный плейлист"
new_playlist = sp.user_playlist_create(
user_id, 
playlist_name, 
public=False, 
description="Создано с помощью Python и Spotify API"
)

# Добавляем треки в плейлист
sp.playlist_add_items(new_playlist['id'], best_matches)

print(f"Создан новый плейлист: {playlist_name}")
print(f"Ссылка: {new_playlist['external_urls']['spotify']}")

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

# Выбираем артиста для анализа
artist_name = "The Beatles"
results = sp.search(q=artist_name, type='artist', limit=1)
artist_id = results['artists']['items'][0]['id']

# Получаем все альбомы
albums = []
results = sp.artist_albums(artist_id, album_type='album', limit=50)
while results:
albums.extend(results['items'])
if results['next']:
results = sp.next(results)
else:
results = None

# Фильтруем дубликаты и сортируем по дате
unique_albums = {}
for album in albums:
name = album['name'].lower()
if name not in unique_albums and album['release_date'] and len(album['release_date']) >= 4:
unique_albums[name] = album

# Сортируем по дате выпуска
sorted_albums = sorted(
unique_albums.values(), 
key=lambda x: x['release_date']
)

evolution_data = []
for album in sorted_albums:
# Получаем все треки альбома
album_tracks = sp.album_tracks(album['id'])['items']
track_ids = [track['id'] for track in album_tracks]

# Получаем характеристики треков
if track_ids:
features = sp.audio_features(track_ids)
features_df = pd.DataFrame([f for f in features if f])

if not features_df.empty:
# Средние характеристики альбома
album_data = {
'name': album['name'],
'year': album['release_date'][:4],
'danceability': features_df['danceability'].mean(),
'energy': features_df['energy'].mean(),
'valence': features_df['valence'].mean(),
'acousticness': features_df['acousticness'].mean()
}
evolution_data.append(album_data)

evolution_df = pd.DataFrame(evolution_data)

# Визуализация эволюции звучания
plt.figure(figsize=(14, 8))

# Создаем график для каждой характеристики
features_to_plot = ['danceability', 'energy', 'valence', 'acousticness']
colors = ['#1DB954', '#1ED760', '#2D46B9', '#F1C40F']

for i, feature in enumerate(features_to_plot):
plt.plot(
evolution_df['year'], 
evolution_df[feature], 
marker='o', 
linestyle='-', 
color=colors[i],
linewidth=2,
label=feature.capitalize()
)

# Добавляем названия альбомов
for i, row in evolution_df.iterrows():
plt.annotate(
row['name'],
(row['year'], row['energy']),
textcoords="offset points",
xytext=(0, 10),
ha='center',
fontsize=8,
rotation=45
)

plt.title(f'Эволюция звучания {artist_name}', fontsize=16)
plt.xlabel('Год выпуска', fontsize=12)
plt.ylabel('Значение характеристики', fontsize=12)
plt.legend(loc='best')
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.savefig(f'{artist_name}_evolution.png', dpi=300)
print(f"График сохранен как {artist_name}_evolution.png")