When thinking of WAV files, you can imagine them to be a long list of sound wave amplitude measurements. The length of this list correlates with the sample rate (samples/sec) and then the file length (sec). So, a 2 second WAV file that contains data sampled at 44,100 samples/sec has 88,400 amplitude measurements stored in a list. 

The SciPy library allows us to easily access this data by using the scipy.io package. To start, let's just try to see the audio data using SciPy.
```python
import scipy.io.wavefile as spw
##I now will use my read function to open chicken.wav
sample=spw.read('chicken.wav')
print(sample)
```
This should print the following to the console:
```python
(44100, array([ 54,  66,  70, ..., -34, -31, -28], dtype=int16))
```
As you can see, the ```read``` function returns the sample rate, the data as an array, and labels the data type. Thus, we have a WAV file sampled at 44,100 samples/sec, represented as an array containing integers. 

What if we just wanted to grab the data in the array? It looks like the variable ```sample``` is a tuple containing the list we want as the second element. Thus, we can use indexing. 
```python
print(sample[1][0])
```
This should print the following to the console:
```python
54
```
Now that we have established how SciPy allows us to make WAV file data explicit, we can explore ways to manipulate this data. 

Basics of Audio Editing using SciPy File I/O

SciPy also allows us create audio, such as sine waves, into WAV files. In combination with NumPy, we can define the sample rate and frequency. This is an example of creating a 100Hz sine wave sampled at 44,100 Hz.
```python 
from scipy.io.wavfile import write
import numpy as np
samplerate = 44100; fs = 100
t = np.linspace(0., 1., samplerate)
amplitude = np.iinfo(np.int16).max
data = amplitude * np.sin(2. * np.pi * fs * t)
write("example.wav", samplerate, data.astype(np.int16))
```

Audio Creation

We can use Matplotlib, NumPy, and the wave module to plot waveforms of WAV files. 
```python 
import matplotlib.pyplot as plt
import numpy as np
import wave
import sys

wav=wave.open('chicken.wav', 'r')
#We only want to use mono files
if wav.getnchannels()==2:
  print('Stereo files are unsupported. Use mono files.')
  sys.exit(0) #Terminates program

raw=wav.readframes(-1) #This reads all frames, returns them in byte form
raw=np.frombuffer(raw, dtype='int16') #Converts bytes to integers
sample_rate=wav.getframerate()
time_=np.linspace(0, len(raw)/sample_rate, num=len(raw))

plt.title("Waveform of Chicken")
plt.plot(time_, raw, color="blue") #Plot time and amplitude
plt.xlabel("Time (s)")
plt.ylabel("Amplitude")
plt.tight_layout()
plt.savefig('chicken.png')
plt.show()
```
This should result in something like this:

Visualization of waveforms

Within the scipy.io package, there is the scipy.io.wavefile module. Use this when dealing with WAV files. It includes these helpful functions:

-read(filename`[`, mmap`]`) Open a WAV file

-writefilename, rate, data) Write a NumPy array as a WAV file.

These objects let us access the data within each WAV file. This data can be edited and then rewritten to create a new, different-sounding WAV file.

Davidson College

SciPy is a great tool for reading certain kinds of files into Python or passing SciPy/NumPy variables into a program such as MATLAB. 

File IO with SciPy

https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read

scipy.io.wavefile.read

https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html#scipy.io.wavfile.write

scipy.io.wavefile.write

https://docs.scipy.org/doc/scipy/reference/tutorial/io.html

File IO with SciPy Documentation

Some helpful MATLAB functions in the scipy.io package include:

-loadmat(file_name`[`, mdict, appendmat]) Load MATLAB file

-savemat(file_name, mdict`[`, appendmat, …]) Save a dictionary of names and arrays into a MATLAB-style .mat file

-whosmat(file_name`[`, appendmat]) List variables inside a MATLAB file

Learn Before

Related

Learn After