Da Python meistens alles kann, was man sich vorstellen kann, einschließlich Abspielen und Aufnehmen von Audio. In diesem Artikel werden Sie mit einigen Python-Bibliotheken und einfachen Methoden vertraut gemacht, die diese Bibliotheken zum Abspielen und Aufnehmen von Sound in Python verwenden. Einige weitere Funktionen werden gegen einige zusätzliche Python-Zeilen ausgetauscht.

Die meisten Audiodateien liegen im MP3- und WAV-Dateiformat vor. WAV-Audiodateien sind das einfachste digitale Audioformat mit verlustfrei hohen Aufnahmeraten, sodass WAV-Dateien im Vergleich zu anderen Formaten groß sind. Aus dem gleichen Grund werden MP3-Formate verwendet, die klein sind und Dateien mit sehr geringem Unterschied zur Gesamtklangqualität komprimieren. Außerdem ist es sehr einfach, WAV mit Open-Source- und kostenloser Software, die über das Internet weit verbreitet ist, in MP3 umzuwandeln.

Audio abspielen

Im Folgenden sind einige Python-Bibliotheken aufgeführt, mit denen Sie verschiedene Audioformate in Python abspielen können, darunter MP3-Formate, WAV-Formate und sogar NumPy-Arrays. 

Methode 1: Verwenden von Playsound

Das gebrauchsfertige Paket zum Abspielen von Audiodateien mit nur einer Codezeile. Man kann damit WAV- oder MP3-Dateien abspielen. Es ist ein einzelner Funktionsbaustein ohne Abhängigkeiten für die Tonwiedergabe. 

In der Dokumentation der PlaySound-Bibliothek wird erwähnt, dass sie auf WAV- und MP3-Dateien getestet wurde, aber möglicherweise auch mit anderen Dateiformaten funktioniert, deren Test dem Benutzer überlassen wurde. Das PlaySound-Modul enthält nur eines - die Funktion (auch benannt) PlaySound.

Es folgen die Codezeilen zum Abspielen einer Datei:

from playsound import playsound  
  
playsound('full_path/filename.mp3')

Ausgabe:

Methode 2: Verwenden von Simpleaudio.

Beispiel 1:

Es ist eine plattformübergreifende Python-Bibliothek für die Wiedergabe von Mono- und Stereo-WAV-Dateien ohne weitere Abhängigkeiten für die Audiowiedergabe. Python 3.7 und höher wird offiziell unter MacOS, Windows und Linux unterstützt. 

Im Folgenden finden Sie den einfachen Code zum Abspielen einer Datei im WAV-Format, obwohl im Vergleich zur obigen Bibliothek nur wenige Codezeilen mehr benötigt werden:

import simpleaudio as sa 
  
import simpleaudio.functionchecks as fc 
fc.run_all() 
  
f_name = 'myfile.wav'
  
wave_obj = sa.WaveObject.from_wave_file(f_name)     
  
play = wave_obj.play()  
            
play.wait_done()   
play.stop()

Ausgabe:

Beispiel 2:

simpleaudio kann verwendet werden, um NumPy- und Python-Arrays & Bytes-Objekte mit simpleaudio.play_buffer() abzuspielen. Numpy-Arrays können zum Speichern von Audio verwendet werden, es gibt jedoch einige entscheidende Anforderungen. Wenn Stereo-Audio gespeichert werden soll, muss das Array zwei Spalten enthalten, die jeweils einen Kanal mit Audiodaten enthalten. Sie müssen außerdem einen vorzeichenbehafteten 16-Bit-Integer-D-Typ haben und die Abtastamplitudenwerte müssen folglich zwischen -32768 und 32767 liegen. Nachfolgend finden Sie den Code zum Generieren eines NumPy-Arrays und zum Wiedergeben mit simpleaudio.play_buffer().

import numpy as np 
import simplesound as sa 
first_freq = 400  
nxt_freq = first_freq * 2 ** (7 / 12) 
  
smpl_rate = 44100
seconds = 3  
  
arr = np.linspace(0, seconds, seconds * smpl_rate, False) 
  
first_note = np.sin(first_freq * arr * 2 * np.pi) 
nxt_note = np.sin(nxt_freq * arr * 2 * np.pi) 
  
tape = np.hstack((first_note,nxt_note)) 
  
tape *= 32767 / np.max(np.abs(tape)) 
  
tape = tape.astype(np.int16) 
  
play = sa.play_buffer(tape, 1, 2, smpl_rate) 
  
play.wait_done() 
play.stop() 

Ausgabe:

Methode 3: Winsound verwenden.

Beispiel 1:

Es ist das integrierte Modul für den Zugriff auf einen grundlegenden Sound-Wiedergabemechanismus. Sie können nur WAV-Dateien abspielen (es werden keine anderen Dateiformate unterstützt) oder Ihren Lautsprecher piepen, aber es funktioniert nur unter Windows, wie der Name schon sagt, WINsound. Es ist das eingebaute Modul, sodass keine zusätzliche Installation erforderlich ist.

import winsound 
  
winsound.PlaySound(path_to_file, winsound.SND_FILENAME) 

Ausgabe:

Beispiel 2:

Es kann auch verwendet werden, um Ihren Lautsprecher zu piepen oder Windows-Standardtöne abzuspielen. Im folgenden Code wird nach dem Windows-Exit-Sound 1000 ms lang ein Piepton von 5000 Hz abgespielt. 

import winsound 
  
winsound.Beep(5000, 1000)   
  
winsound.PlaySound("SystemExit", winsound.SND_ALIAS) 

Ausgabe:

Der Hauptnachteil dieser Bibliothek besteht darin, dass sie nur für Benutzer von Windows-Betriebssystemen bestimmt ist und auch keine anderen Dateien als WAV-Formate wiedergibt.

Methode 4: Verwenden von Soundgeräten.

Dieses Python-Modul bietet Bindungen für die PortAudio-Bibliothek und einige praktische Funktionen zum Abspielen und Aufzeichnen von NumPy-Arrays, die Audiosignale enthalten. Es ist für Linux-, MacOS- und Windows-Betriebssysteme verfügbar.

Im folgenden Code extrahiert eine Zeile mit 'sf.read()' alle rohen Audiodaten zusammen mit der Abtastrate der Datei, wie sie in ihrem RIFF-Header gespeichert ist. und 'sounddevice.wait()' stellt sicher, dass das Skript beendet wird, nachdem 'sd.play (data, sr)' die Audiowiedergabe beendet hat.

import sounddevice as sd 
import soundfile as sf 
  
array, smp_rt = sf.read(path_of_file, dtype = 'float32')   
  
sd.play(array, smp_rt) 
  
status = sd.wait()   
  
sd.stop() 

Ausgabe:

Methode 5: Verwenden von pydub.

 Obwohl pydub WAV-Dateien ohne weitere Abhängigkeiten problemlos öffnen und speichern kann, muss mindestens ein Audiowiedergabepaket von (simpleaudio, pyaudio, ffplay und avplay) vorinstalliert sein. Es bietet eine reine Python-Implementierung für die Audiomanipulation.

Nach dem Code werden zwei Bibliotheken importiert, die erste Bibliothek zum Laden der Datei und die zweite Bibliothek zum Abspielen der geladenen Datei. Außerdem werden zwei Möglichkeiten zum Laden der WAV-Datei dargestellt.

from pydub import AudioSegment 
from pydub.playback import play 
  
tape = AudioSegment.from_file('path_to_myfile.wav', format='wav') 
tape = AudioSegment.from_wav('path_to_myfile.wav') 
  
play(tape)

Ausgabe:

Methode 6: Verwenden von Pyaudio.

PyAudio ist eine weitere plattformübergreifende Audiobibliothek für Python. Es verfügt zwar über mehr Funktionen als eine einfache Audiobibliothek, z. B. Aufzeichnung und kontinuierliches Audio-Streaming, hängt jedoch weitgehend von PortAudio ab, was zu einer komplizierteren Installation führt. Es bietet auch Python-Bindungen für PortAudio, die plattformübergreifende Audio-E / A-Bibliothek von python-sounddevice. Mit PyAudio können Sie Python problemlos zum Abspielen und Aufnehmen von Audio auf einer Vielzahl von Plattformen verwenden.

import pyaudio 
import wave 
  
filename = 'path-to_file.wav'
  
chunk = 1024  
  
af = wave.open(filename, 'rb') 
  
pa = pyaudio.PyAudio() 
  
stream = pa.open(format = pa.get_format_from_width(af.getsampwidth()), 
                channels = af.getnchannels(), 
                rate = af.getframerate(), 
                output = True) 
  
rd_data = af.readframes(chunk) 
  
while rd_data != '': 
    stream.write(rd_data) 
    rd_data = af.readframes(chunk) 
  
stream.stop_stream() 
stream.close() 
pa.terminate() 

Ausgabe:

Audio aufnehmen

Wechseln Sie jetzt einfach in den Aufnahmemodus des Artikels. Nur wenige der oben genannten Bibliotheken werden für dasselbe verwendet. Sowohl das Abspielen als auch das Aufnehmen können gemeinsam erklärt werden, aber für viele kann es etwas verwirrend werden. Daher werden hier unterschiedliche Abschnitte bevorzugt.

Hinweis - Bevor Sie eine Bibliothek für die Aufnahme verwenden, stellen Sie sicher, dass das Mikrofon Ihres Geräts tatsächlich angeschlossen und eingeschaltet ist und nicht stummgeschaltet ist. Sie können dies auch anhand der Funktionen und Einstellungen des Betriebssystems überprüfen.

Methode 1. Verwenden von Python-Sound-Gerät

Mit dieser Bibliothek können Sie NumPy-Arrays mit Audiosignalinformationen abspielen (siehe oben) und aufnehmen. Für dieses Modul ist scipy oder wavio erforderlich, um das aufgenommene Audio zu speichern. Dies bedeutet, dass die scipy- oder wavio-Bibliothek zusammen mit Numpy vorinstalliert sein sollte, bevor dieses Paket für die Aufnahme verwendet wird.

import sounddevice as sd 
from scipy.io.wavfile import write 
import wavio as wv 
  
frequency = 44400
  
duration = 3.5
  
recording = sd.rec(int(duration * frequency), 
                   samplerate = freq, channels = 2) 
  
sd.wait() 
  
write("recording0.wav", freq, recording) 
  
wv.write("recording1.wav", recording, freq, sampwidth=2)

Ausgabe:

Wie im Abschnitt Audio angegeben, hatte sounddevice eine Standardoption, um den Kanal und die Frequenz für die wiederholte Verwendung anzugeben. Danach müssen Sie diese Option nicht mehr als Argumente in der Methode sd.rec() übergeben. Der folgende Code stellt dasselbe dar und man kann auch den Datentyp des aufgezeichneten Arrays vom Standardtyp von float32 in einen anderen ändern.

import sounddevice as sd 
  
sd.default.samplerate = 4400
sd.default.channels = 2
  
myrecording = sd.rec(int(duration * fs)) 
  
  
sd.wait()

Gleichzeitige Wiedergabe und Aufnahme

Ein Array mit dem Namen my_arr und Record gleichzeitig abspielen. Hier ist die Abtastrate smpl_rate

import sounddevice as sd 
import numpy as np 
  
smpl_rate = 44100
  
my_arr = np.random.uniform(-1,1,smpl_rate) 
recordd= sd.playrec(my_arr, smpl_rate, channels=2) 
  
sd.wait()

Methode 2: Verwenden von Pyaudio.

Wie oben haben wir Audio mit pyaudio abgespielt, indem wir pyaudio.Stream() gelesen haben. Um Audio aufzunehmen, müssen wir in denselben Stream schreiben. Im Folgenden finden Sie den Code, mit dem Sie einige Sekunden Audio aufnehmen und in einer WAV-Datei speichern können:

import pyaudio 
import wave 
  
chunk = 1024  
  
sample_format = pyaudio.paInt16   
chanels = 2
  
smpl_rt = 44400  
seconds = 4
filename = "path_of_file.wav"
  
pa = pyaudio.PyAudio()   
  
stream = pa.open(format=sample_format, channels=chanels,  
                 rate=smpl_rt, input=True,  
                 frames_per_buffer=chunk) 
  
print('Recording...') 
  
frames = []   
  
for i in range(0, int(smpl_rt / chunk * seconds)): 
    data = stream.read(chunk) 
    frames.append(data) 
  
stream.stop_stream() 
stream.close() 
  
pa.terminate() 
  
print('Done !!! ') 
  
sf = wave.open(filename, 'wb') 
sf.setnchannels(chanels) 
sf.setsampwidth(pa.get_sample_size(sample_format)) 
sf.setframerate(smpl_rt) 
sf.writeframes(b''.join(frames)) 
sf.close() 

Ausgabe: