❶ python3.5scipy包怎样读取wav文件
用语音处理的库
楼主找找
pyb 提供了简洁的高层接口，极大的扩展了python处理音频文件的能力，pyb可能不是最强大的Python音频处理库，但绝对是Python最简洁易用的音频库只要，非要说有什么弊端，大概只有高度依赖ffmpeg，Linux安装起来不太方便吧。
❷ python中引入pyttsx3包然后用这个包实现文本转换成的语音engine.say()怎么存储成WAV文件
pyttsx 是一个Python的第三方包，支持在Mac OS X, Windows, Linux 实现文字转语言( text-to-speech)~
❸ 谁知道如何在python中用处理wav文件，并且对他的频谱进行分析的程序
1.读取wav文件
# -*- coding: utf-8 -*-
import wave
import pylab as pl
import numpy as np
# 打开WAV文档
f = wave.open(r"c:\WINDOWS\Media\ding.wav", "rb")
# 读取格式信息
# (nchannels, sampwidth, framerate, nframes, comptype, compname)
params = f.getparams()
nchannels, sampwidth, framerate, nframes = params[:4]
# 读取波形数据
str_data = f.readframes(nframes)
f.close()
#将波形数据转换为数组
wave_data = np.fromstring(str_data, dtype=np.short)
wave_data.shape = -1, 2
wave_data = wave_data.T
time = np.arange(0, nframes) * (1.0 / framerate)
# 绘制波形
pl.subplot(211)
pl.plot(time, wave_data[0])
pl.subplot(212)
pl.plot(time, wave_data[1], c="g")
pl.xlabel("time (seconds)")
pl.show()
2.观察信号频谱
# -*- coding: utf-8 -*-
import numpy as np
import pylab as pl
sampling_rate = 8000
fft_size = 512
t = np.arange(0, 1.0, 1.0/sampling_rate)
x = np.sin(2*np.pi*156.25*t) + 2*np.sin(2*np.pi*234.375*t)
xs = x[:fft_size]
xf = np.fft.rfft(xs)/fft_size
freqs = np.linspace(0, sampling_rate/2, fft_size/2+1)
xfp = 20*np.log10(np.clip(np.abs(xf), 1e-20, 1e100))
pl.figure(figsize=(8,4))
pl.subplot(211)
pl.plot(t[:fft_size], xs)
pl.xlabel(u"时间(秒)")
pl.title(u"156.25Hz和234.375Hz的波形和频谱")
pl.subplot(212)
pl.plot(freqs, xfp)
pl.xlabel(u"频率(Hz)")
pl.subplots_adjust(hspace=0.4)
pl.show()
❹ python语言录制声音和保存wav文件的库文件是什么
是pyaudio。
因为录音，是由计算机内部声卡实现的，所以我们需要利用pyaudio库调用声卡进行声音录制，而保存音频文件我们可以使用python自带的wave库来将音频保存为wav音频文件，所以python语言录制声音和保存wav文件的库文件是pyaudio。
语言录音又称对白录音，有声影片电影录音的主要工作内容之一，根据影片的内容和艺术要求，把演员的对白、旁白和内心独白记录下来的过程。
❺ python 怎么录制系统声音不只是麦克风声音
#我可以帮你写一段代码，能够录音形成wav文件，不过要分析录音文件的波形，你可以另外找#工具，比如cooledit，也很方便。
from sys import byteorder
from array import array
from struct import pack
import pyaudio
import wave
THRESHOLD = 500
CHUNK_SIZE = 1024
FORMAT = pyaudio.paInt16
RATE = 44100
def is_silent(snd_data):
"Returns 'True' if below the 'silent' threshold"
return max(snd_data) < THRESHOLD
def normalize(snd_data):
"Average the volume out"
MAXIMUM = 16384
times = float(MAXIMUM)/max(abs(i) for i in snd_data)
r = array('h')
for i in snd_data:
r.append(int(i*times))
return r
def trim(snd_data):
"Trim the blank spots at the start and end"
def _trim(snd_data):
snd_started = False
r = array('h')
for i in snd_data:
if not snd_started and abs(i)>THRESHOLD:
snd_started = True
r.append(i)
elif snd_started:
r.append(i)
return r
# Trim to the left
snd_data = _trim(snd_data)
# Trim to the right
snd_data.reverse()
snd_data = _trim(snd_data)
snd_data.reverse()
return snd_data
def add_silence(snd_data, seconds):
"Add silence to the start and end of 'snd_data' of length 'seconds' (float)"
r = array('h', [0 for i in xrange(int(seconds*RATE))])
r.extend(snd_data)
r.extend([0 for i in xrange(int(seconds*RATE))])
return r
def record():
"""
Record a word or words from the microphone and
return the data as an array of signed shorts.
Normalizes the audio, trims silence from the
start and end, and pads with 0.5 seconds of
blank sound to make sure VLC et al can play
it without getting chopped off.
"""
p = pyaudio.PyAudio()
stream = p.open(format=FORMAT, channels=1, rate=RATE,
input=True, output=True,
frames_per_buffer=CHUNK_SIZE)
num_silent = 0
snd_started = False
r = array('h')
while 1:
# little endian, signed short
snd_data = array('h', stream.read(CHUNK_SIZE))
if byteorder == 'big':
snd_data.byteswap()
r.extend(snd_data)
silent = is_silent(snd_data)
if silent and snd_started:
num_silent += 1
elif not silent and not snd_started:
snd_started = True
if snd_started and num_silent > 30:
break
sample_width = p.get_sample_size(FORMAT)
stream.stop_stream()
stream.close()
p.terminate()
r = normalize(r)
r = trim(r)
r = add_silence(r, 0.5)
return sample_width, r
def record_to_file(path):
"Records from the microphone and outputs the resulting data to 'path'"
sample_width, data = record()
data = pack('<' + ('h'*len(data)), *data)
wf = wave.open(path, 'wb')
wf.setnchannels(1)
wf.setsampwidth(sample_width)
wf.setframerate(RATE)
wf.writeframes(data)
wf.close()
if __name__ == '__main__':
print("please speak a word into the microphone")
record_to_file('demo.wav')
print("done - result written to demo.wav")
❻ 利用python编写代码如何把wav文件转为mp3文件
using lame (command line), you can encode wav to mp3 like this:
$ lame --preset insane /path/to/file.wav
which would create:
file.wav.mp3
in Python, you could use subprocess to call it:
wav = 'myfile.wav'
cmd = 'lame --preset insane %s' % wav
subprocess.call(cmd, shell=True)
❼ Python播放wav音频，在Windows系统下
手头正好一个脚本，在Windows下执行没有问题。供参考：
importwinsound,time,sys
mp3='qed.wav'
if__name__=='__main__':
iflen(sys.argv)<2:
times=1
else:
times=int(sys.argv[1])
iftimes==0:
while1:
winsound.PlaySound(mp3,winsound.SND_NODEFAULT)
else:
foriinrange(times):
winsound.PlaySound(mp3,winsound.SND_NODEFAULT)
❽ 为什么python转换的wav不能播放,必须用sox转换
格式不支持。python转换的wav只可用于储存格式，不可用于读取（播放）格式，想要播放必须使用sox插件进行转换。
❾ python怎么把一个32bit float编码的pcm数据转换成wav文件，或者说setsampwidth的参数应该是什么
就一般情况而言，大多数的wav音频文件就是pcm编码的，所以不用转。
所以你应该把问题描述清楚：你想把pcm编码转成什么编码？
❿ 怎样用python画wav文件的时频分析图
这是python的matplotlib里的一个画wav文件的时频分析（specgram）的函数。和matlab里的那个差不多。使用超级方便，自动就做好了短时傅立叶变换(short
time fourier
transform)～函数用法具体可参照http://matplotlib.sourceforge.net/api/pyplot_api.html#matplotlib.pyplot.specgram
关于短时傅立叶变换的具体内容可google之～下面介绍程序。
＃首先import各种library。wave和struct都是安装python2.6自带的。scipy可以在
＃http://www.scipy.org/Download下载。pylab可在http://matplotlib.sourceforge.net/下载。都是非常＃强大的包包啊～～
import wave
import struct
from scipy import *
from pylab import *
＃读取wav文件，我这儿读了个自己用python写的音阶的wav
filename = '/Users/rongjin/Desktop/scale.wav'
wavefile = wave.open(filename, 'r') # open for writing
＃读取wav文件的四种信息的函数。期中numframes表示一共读取了几个frames，在后面要用到滴。
nchannels = wavefile.getnchannels()
sample_width = wavefile.getsampwidth()
framerate = wavefile.getframerate()
numframes = wavefile.getnframes()
＃建一个y的数列，用来保存后面读的每个frame的amplitude。
y = zeros(numframes)
＃for循环，readframe(1)每次读一个frame，取其前两位，是左声道的信息。右声道就是后两位啦。
＃unpack是struct里的一个函数，用法详见http://docs.python.org/library/struct.html。简单说来
就是把＃packed的string转换成原来的数据，无论是什么样的数据都返回一个tuple。这里返回的是长度为一的一个
＃tuple，所以我们取它的第零位。
for i in range(numframes):
val =
wavefile.readframes(1)
left =
val[0:2]
#right = val[2:4]
v =
struct.unpack('h', left )[0]
y[i] =
v
＃framerate就是44100，文件初读取的值。然后本程序最关键的一步！specgram！实在太简单了。。。
Fs = framerate
specgram(y, NFFT=1024, Fs=Fs, noverlap=900)
show()
耶～好看的specgram就画好了～～x轴是时间，y轴是频率～