引言

WAV（Waveform Audio File Format）是一种主流的音频文件格式，因其无损压缩特性，在音频处理、语音识别、音乐分析等领域有着广泛应用。Python凭借丰富的音频处理库，为WAV文件的操作提供了强大而灵活的解决方案。本文将系统介绍使用Python处理WAV音频文件的技术方案。

一、核心库介绍

1.1 wave（标准库）

Python内置的wave模块支持基础WAV文件读写，但仅支持PCM编码的未压缩格式。

1.2 scipy.io.wavfile

SciPy库中的wavfile模块提供简洁的读写接口，返回numpy数组便于数值计算。

1.3 soundfile

基于libsndfile库，支持多种音频格式，API友好。

1.4 librosa

专业音乐与音频分析库，内置特征提取、时频变换等高级功能。

1.5 pydub

高封装度库，支持切片、拼接、音量调整等操作，易于上手。

二、安装依赖

bash

pip install numpy scipy soundfile librosa pydub matplotlib
# pydub需要ffmpeg支持
# Ubuntu/Debian: sudo apt-get install ffmpeg
# macOS: brew install ffmpeg

三、读取WAV文件

3.1 使用wave标准库

python

import wave
import numpy as np

def read_wave_wave(filepath):
    with wave.open(filepath, 'rb') as wav:
        # 获取音频参数
        params = {
            'nchannels': wav.getnchannels(),
            'sampwidth': wav.getsampwidth(),
            'framerate': wav.getframerate(),
            'nframes': wav.getnframes()
        }
        # 读取原始帧数据
        frames = wav.readframes(params['nframes'])
        # 转换为numpy数组
        dtype = np.int16 if params['sampwidth'] == 2 else np.int32
        audio_data = np.frombuffer(frames, dtype=dtype)
        # 双声道重塑为2列
        if params['nchannels'] == 2:
            audio_data = audio_data.reshape(-1, 2)
    return audio_data, params['framerate']

3.2 使用scipy.io.wavfile

python

from scipy.io import wavfile

def read_wave_scipy(filepath):
    sample_rate, audio_data = wavfile.read(filepath)
    # audio_data为numpy数组，单声道形状(n,)，双声道形状(n,2)
    return audio_data, sample_rate

3.3 使用soundfile

python

import soundfile as sf

def read_wave_soundfile(filepath):
    audio_data, sample_rate = sf.read(filepath)
    # audio_data为float64范围[-1, 1]
    return audio_data, sample_rate

3.4 使用librosa

python

import librosa

def read_wave_librosa(filepath, sr=None):
    # sr=None保持原始采样率，否则重采样
    audio_data, sample_rate = librosa.load(filepath, sr=sr)
    return audio_data, sample_rate

四、写入WAV文件

4.1 使用scipy写入

python

from scipy.io import wavfile

def write_wave_scipy(filepath, sample_rate, audio_data):
    # 确保数据类型为int16或int32
    if audio_data.dtype not in [np.int16, np.int32]:
        # 归一化到int16范围
        audio_data = (audio_data * 32767).astype(np.int16)
    wavfile.write(filepath, sample_rate, audio_data)

4.2 使用soundfile写入

python

import soundfile as sf

def write_wave_soundfile(filepath, audio_data, sample_rate):
    # audio_data范围[-1, 1] float
    sf.write(filepath, audio_data, sample_rate)

五、常用音频处理操作

5.1 声道转换

python

def mono_to_stereo(mono_audio):
    """单声道转双声道"""
    return np.column_stack((mono_audio, mono_audio))

def stereo_to_mono(stereo_audio):
    """双声道转单声道（平均）"""
    return np.mean(stereo_audio, axis=1)

5.2 重采样

python

from scipy import signal

def resample_audio(audio_data, orig_sr, target_sr):
    """重采样音频"""
    # 计算重采样比例
    resample_ratio = target_sr / orig_sr
    # 计算新长度
    new_length = int(len(audio_data) * resample_ratio)
    # 使用scipy重采样
    resampled = signal.resample(audio_data, new_length)
    return resampled, target_sr

5.3 音量调整

python

def adjust_volume(audio_data, gain_db):
    """调整音量，gain_db单位为分贝"""
    factor = 10 ** (gain_db / 20.0)
    return audio_data * factor

5.4 音频裁剪

python

def trim_audio(audio_data, sample_rate, start_sec, end_sec):
    """按秒裁剪音频"""
    start_sample = int(start_sec * sample_rate)
    end_sample = int(end_sec * sample_rate)
    return audio_data[start_sample:end_sample]

5.5 音频拼接

python

def concatenate_audios(audio_list):
    """拼接多个音频（同一采样率）"""
    return np.concatenate(audio_list, axis=0)

5.6 添加静音段

python

def add_silence(audio_data, sample_rate, silence_sec, position='end'):
    """添加静音段"""
    silence_samples = int(silence_sec * sample_rate)
    silence = np.zeros(silence_samples if audio_data.ndim == 1 
                       else (silence_samples, audio_data.shape[1]))
    
    if position == 'start':
        return np.concatenate([silence, audio_data])
    elif position == 'end':
        return np.concatenate([audio_data, silence])
    else:
        raise ValueError("position must be 'start' or 'end'")

5.7 时频变换（Fourier Transform）

python

import numpy as np
import matplotlib.pyplot as plt

def compute_spectrogram(audio_data, sample_rate, n_fft=2048, hop_length=512):
    """计算并绘制频谱图"""
    from scipy.signal import spectrogram
    
    f, t, Sxx = spectrogram(audio_data, fs=sample_rate, 
                            nperseg=n_fft, noverlap=n_fft-hop_length)
    
    # 转换为dB刻度
    Sxx_db = 10 * np.log10(Sxx + 1e-10)
    
    plt.figure(figsize=(10, 6))
    plt.pcolormesh(t, f, Sxx_db, shading='gouraud', cmap='inferno')
    plt.ylabel('Frequency [Hz]')
    plt.xlabel('Time [sec]')
    plt.colorbar(label='Intensity [dB]')
    plt.title('Spectrogram')
    plt.show()
    
    return f, t, Sxx

六、完整应用示例：音频批处理器

python

import os
import numpy as np
import soundfile as sf
from scipy import signal
from typing import Tuple, Optional

class AudioProcessor:
    """音频处理器类，封装常用操作"""
    
    def __init__(self, filepath: Optional[str] = None):
        self.filepath = filepath
        self.audio_data = None
        self.sample_rate = None
        
        if filepath and os.path.exists(filepath):
            self.load(filepath)
    
    def load(self, filepath: str) -> 'AudioProcessor':
        """加载音频文件"""
        self.filepath = filepath
        self.audio_data, self.sample_rate = sf.read(filepath)
        return self
    
    def save(self, filepath: str) -> 'AudioProcessor':
        """保存音频文件"""
        sf.write(filepath, self.audio_data, self.sample_rate)
        return self
    
    def info(self) -> dict:
        """获取音频信息"""
        if self.audio_data is None:
            return {}
        
        info = {
            'sample_rate': self.sample_rate,
            'duration': len(self.audio_data) / self.sample_rate,
            'channels': 1 if self.audio_data.ndim == 1 else self.audio_data.shape[1],
            'dtype': str(self.audio_data.dtype),
            'shape': self.audio_data.shape,
            'max_amplitude': np.max(np.abs(self.audio_data)),
            'rms': np.sqrt(np.mean(self.audio_data ** 2))
        }
        return info
    
    def resample(self, target_sr: int) -> 'AudioProcessor':
        """重采样"""
        if target_sr == self.sample_rate:
            return self
        
        # 计算新长度
        new_length = int(len(self.audio_data) * target_sr / self.sample_rate)
        
        # 处理多声道
        if self.audio_data.ndim == 1:
            self.audio_data = signal.resample(self.audio_data, new_length)
        else:
            resampled = []
            for ch in range(self.audio_data.shape[1]):
                resampled.append(signal.resample(self.audio_data[:, ch], new_length))
            self.audio_data = np.column_stack(resampled)
        
        self.sample_rate = target_sr
        return self
    
    def normalize(self, target_level: float = 0.95) -> 'AudioProcessor':
        """归一化到目标峰值电平"""
        peak = np.max(np.abs(self.audio_data))
        if peak > 0:
            self.audio_data = self.audio_data * (target_level / peak)
        return self
    
    def apply_fade(self, fade_in_sec: float = 0, fade_out_sec: float = 0) -> 'AudioProcessor':
        """应用淡入淡出效果"""
        fade_in_samples = int(fade_in_sec * self.sample_rate)
        fade_out_samples = int(fade_out_sec * self.sample_rate)
        
        if fade_in_samples > 0:
            fade_curve = np.linspace(0, 1, fade_in_samples)
            if self.audio_data.ndim == 1:
                self.audio_data[:fade_in_samples] *= fade_curve
            else:
                for ch in range(self.audio_data.shape[1]):
                    self.audio_data[:fade_in_samples, ch] *= fade_curve
        
        if fade_out_samples > 0:
            fade_curve = np.linspace(1, 0, fade_out_samples)
            if self.audio_data.ndim == 1:
                self.audio_data[-fade_out_samples:] *= fade_curve
            else:
                for ch in range(self.audio_data.shape[1]):
                    self.audio_data[-fade_out_samples:, ch] *= fade_curve
        
        return self
    
    def extract_features(self) -> dict:
        """提取音频特征"""
        import librosa
        
        # 转为单声道用于特征提取
        mono = np.mean(self.audio_data, axis=1) if self.audio_data.ndim > 1 else self.audio_data
        
        features = {
            'zero_crossing_rate': librosa.feature.zero_crossing_rate(mono).mean(),
            'rms_energy': librosa.feature.rms(y=mono).mean(),
            'spectral_centroid': librosa.feature.spectral_centroid(y=mono, sr=self.sample_rate).mean(),
            'spectral_bandwidth': librosa.feature.spectral_bandwidth(y=mono, sr=self.sample_rate).mean(),
            'spectral_rolloff': librosa.feature.spectral_rolloff(y=mono, sr=self.sample_rate).mean(),
        }
        
        # 提取MFCC
        mfcc = librosa.feature.mfcc(y=mono, sr=self.sample_rate, n_mfcc=13)
        for i in range(13):
            features[f'mfcc_{i+1}'] = mfcc[i].mean()
        
        return features

# 使用示例
if __name__ == "__main__":
    # 创建处理器实例
    processor = AudioProcessor("input.wav")
    
    # 查看信息
    print("原始音频信息:", processor.info())
    
    # 处理流水线
    (processor
     .resample(16000)           # 重采样到16kHz
     .normalize(0.9)            # 归一化
     .apply_fade(0.1, 0.1)      # 淡入淡出各0.1秒
     .save("output.wav"))       # 保存
    
    # 提取特征
    features = processor.extract_features()
    print("音频特征:", features)

七、性能优化建议

1. 内存管理：处理长音频时使用分块处理

2. 避免数据类型转换：尽量保持原始dtype

3. 使用numpy向量化操作：避免Python循环

4. 考虑使用numba加速：对计算密集型操作

python

def process_in_chunks(audio_data, chunk_size=44100*10, callback_func):
    """分块处理长音频"""
    for i in range(0, len(audio_data), chunk_size):
        chunk = audio_data[i:i+chunk_size]
        processed_chunk = callback_func(chunk)
        yield processed_chunk

八、总结

Python生态提供了从基础读写到高级分析的完整WAV处理方案。根据需求选择合适的库：

• 简单读写：scipy.io.wavfile或soundfile

• 信号处理：scipy.signal + numpy

• 音乐分析：librosa

• 快速原型：pydub

以上方案覆盖了90%以上的音频处理场景，可根据具体项目灵活组合使用。