A Comprehensive Guide to Reading WAV Audio Files in Python: From Basics to Practice

Introduction

In audio signal processing and analysis, WAV files are a common lossless audio format widely used in various applications. Python offers multiple libraries for reading and handling WAV files, but beginners often face challenges in data parsing and format conversion. Based on real-world Q&A data, this article systematically outlines core methods for reading WAV files, aiming to help readers master the conversion process from binary data to numerical arrays.

Using scipy.io.wavfile.read to Read WAV Files

scipy.io.wavfile.read is one of the most convenient methods for handling WAV files. It returns a tuple containing the sampling rate and an array of audio data. The sampling rate, expressed in samples per second, determines the temporal resolution of the audio, while the data array stores amplitude values of the audio signal. For example, the following code demonstrates how to read a WAV file:

from scipy.io import wavfile
samplerate, data = wavfile.read('./output/audio.wav')
print(f"Sampling rate: {samplerate} Hz")
print(f"Data shape: {data.shape}")
print(f"Data type: {data.dtype}")

This method directly returns a NumPy array, facilitating subsequent mathematical operations and visualization. Data is typically stored as integers, such as 16-bit signed integers (int16) ranging from -32768 to 32767. If normalization to a floating-point range of -1.0 to 1.0 is required, conversion can be done based on bit depth:

if data.dtype == 'int16':
    data = data / 32768.0
elif data.dtype == 'int32':
    data = data / 2147483648.0

This conversion ensures data consistency across different libraries, such as compatibility with SoundFile, which returns floating-point numbers.

Parsing Raw Data with the wave Module and struct

For scenarios requiring lower-level control, Python's built-in wave module provides direct access to the binary data of WAV files. Combined with the struct module, frame data can be manually parsed. The following example shows how to read a mono, 16-bit WAV file:

import wave
import struct

wavefile = wave.open('sine.wav', 'r')
length = wavefile.getnframes()
for i in range(length):
    wavedata = wavefile.readframes(1)
    sample = struct.unpack("<h", wavedata)
    print(int(sample[0]))
wavefile.close()

Here, struct.unpack("<h", wavedata) uses little-endian (<) and short integer (h) formats to parse binary data. For reading multiple frames, the number of frames can be specified:

wavedata = wavefile.readframes(13)
data = struct.unpack("<13h", wavedata)

Although flexible, this approach requires handling byte order and data types, making it suitable for custom audio processing logic.

Introduction to Other Common Libraries

Beyond the above methods, several libraries in the Python ecosystem support WAV file reading:

• SoundFile: Returns floating-point arrays in the range -1.0 to 1.0, consistent with MATLAB conventions. Example code: import soundfile as sf; data, samplerate = sf.read('existing_file.wav').
• librosa: Focuses on music and audio analysis, offering advanced feature extraction.
• sounddevice: Suitable for real-time audio stream processing.

Output formats may vary between libraries; for instance, scipy returns integers, while SoundFile returns floats. In practice, choose a library based on needs and pay attention to data normalization.

Practical Cases and Common Issues

In early attempts, users often encounter issues where wave.readframes returns byte objects, leading to garbled output. This occurs because audio data is stored in binary form and must be parsed into numerical values. An improved, generic code example:

import wave
import struct

file_name = 'sample.wav'
w = wave.open(file_name, 'rb')
channels = w.getnchannels()
sample_width = w.getsampwidth()
frame_rate = w.getframerate()
num_frames = w.getnframes()

frames = w.readframes(num_frames)
if sample_width == 2:  # 16-bit audio
    format_str = f'<{num_frames * channels}h'
    wave_form = struct.unpack(format_str, frames)
w.close()

This code dynamically generates format strings to adapt to varying frame counts and channels, avoiding hard-coded issues. Additionally, Python variables do not require pre-declaration and can be assigned directly, differing from languages like C.

Summary and Recommendations

The core of reading WAV files lies in understanding the binary representation of audio data and numerical conversion. For rapid prototyping and analysis, scipy.io.wavfile.read is recommended; for low-level operations, the combination of wave and struct offers more flexibility; and for advanced audio processing, SoundFile or librosa may be more appropriate. In practice, attention to data types, byte order, and normalization is crucial to ensure accuracy and interoperability. By mastering these methods, users can efficiently perform audio signal processing, laying a foundation for further analysis.