Python_Numpy

Numpy笔记

numpy.fft.hfft方法

• 格式: numpy.fft.hfft(a, n=None, axis=-1, norm=None)
• 计算具有Hermitian对称性（即实谱）的信号的FFT。即真实频谱。
  numpy.fft.hfft
  numpy.fft.hfft(a, n=None, axis=-1, norm=None)
  计算具有Hermitian对称性（即实谱）的信号的FFT。即真实频谱。
  参数：
  a ：array_like
  输入数组。
  b ：int, 可选
  输出的转换轴的长度。 对于n个输出点，
  需要n//2 + 1个输入点。
  如果输入长于此长度，则将对其进行裁剪。
  如果比这短，则用零填充。 如果未给出n，
  则将其取为2*(m-1)，
  其中m是沿axis指定的轴的输入长度。
  axis ：int, 可选
  计算FFT的轴。如果没有给出，则使用最后一个轴。
  norm ：{None, “ortho”}, 可选
  规范化模式（请参阅numpy.fft）。 默认为None。
  1.10.0版中的新功能。
  返回值：
  out ：ndarray
  截断的或零填充的输入，
  沿着由轴表示的轴进行转换，
  或者如果轴未指定，则为最后一个。
  变换轴的长度为n，如果n不给定，
  则为2m - 2，其中m为输入的变换轴的长度。
  要得到奇数个输出点，必须指定n，
  例如在典型情况下为2m - 1，
  Raises：
  IndexError
  如果axis大于a的最后一个轴。
  Notes
  hfft/ ihfft是一对类似于rfft/ irfft，但是对于相反的情况：在这里该信号具有在时域对称性厄米和是在频域中实际。因此，hfft如果结果是奇数，必须在此处提供结果的长度。
  偶数：在舍入误差内，ihfft(hfft(a, 2len(a) - 2)) == a
  奇数：，舍入误差内。ihfft(hfft(a, 2len(a) - 1)) == a
  厄米输入的正确解释取决于原始数据的长度，如n所示。这是因为每种输入形状可能对应于奇数或偶数长度的信号。默认情况下，hfft 假设输出长度是偶数，这会将最后一个条目置于奈奎斯特频率；与其对称对应物混叠。通过埃尔米特对称性，该值因此被视为纯实数。为了避免丢失信息，必须给出完整信号的形状。

>>> signal = np.array([1,2,3,4,3,2])
>>> np.fft.fft(signal)
array([15.+0.j, -4.+0.j,  0.+0.j, -1.+0.j,  0.+0.j, -4.+0.j])
>>> np.fft.hfft(signal[:4])
array([15., -4.,  0., -1.,  0., -4.])
>>> np.fft.hfft(signal,6)
array([15., -4.,  0., -1.,  0., -4.])
>>> freq_spectrum = np.fft.hfft(signal)
>>> freq_spectrum
array([[ 1.,  1.],
       [ 2., -2.]])

numpy.asarray函数

• numpy.asarray(a, dtype=None, order=None)
• 和array基础功能都是将序列转换为ndarray，不同的是
• 如果转换对象为一个ndarray，只有dtype不相同时才复制数据
• 与后面的asnyarray不同的是，它子类未传递

>>> a = np.asarray(a)
>>> a
array([1, 2])
>>> a = [1,2]
>>> type(a)
<class 'list'>
>>> a = np.array([1,2],dtype=np.float32)
>>> np.asarray(a,dtype=np.float32) is a
True
>>> np.asarray(a,dtype=np.float64) is a
False
>>> issubclass(np.recarray,np.ndarray)
True

numpy.asanyarray函数

• 格式: numpy.asanyarray(a, dtype=None, order=None)
• 功能: 类似asarray,将一个序列转换为ndarray,传递子类

>>> np.asanyarray(range(5))
array([0, 1, 2, 3, 4])

numpy.ascontiguousarray函数

• 格式: numpy.ascontiguousarray(a, dtype=None)

>>> x = np.arange(6).reshape(2,3)
>>> np.ascontiguousarray(x,dtype=np.float32)
array([[0., 1., 2.],
       [3., 4., 5.]], dtype=float32)
>>> b = np.arange(6).reshape(2,3)
>>> b
array([[0, 1, 2],
       [3, 4, 5]])
>>> x.flags['C_CONTIGUOUS']
True
#注意：此函数返回一个至少具有一维（1-d）的数组，因此它将不保留0-d数组。

numpy.copy函数

• 格式: numpy.copy(a, order=‘K’, subok=False)
• 功能: 返回给对象ndarray副本,等效于np.array(a,copy=True)
• 请注意：
  np.copy是浅表副本，不会复制数组中的对象元素。这对于包含Python对象的数组非常重要。
  新数组将包含相同的对象，如果可以修改（可变）该对象，则可能会导致意外：
  要确保object复制数组中的所有元素，请使用copy.deepcopy：

>>> x = np.arange(6).reshape(2,3)
>>> x
array([[0, 1, 2],
       [3, 4, 5]])
>>> y = x
>>> x[0] = 10
>>> x
array([[10, 10, 10],
       [ 3,  4,  5]])
>>> y
array([[10, 10, 10],
       [ 3,  4,  5]])
>>> z = np.copy(x)
>>> x[0] = 5
>>> x
array([[5, 5, 5],
       [3, 4, 5]])
>>> y
array([[5, 5, 5],
       [3, 4, 5]])
>>> z
array([[10, 10, 10],
       [ 3,  4,  5]])

numpy.frombuffer函数

• 格式: numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)
• 功能: 将缓冲区解释为一维数组。
  buffer ：buffer_like
  公开缓冲区接口的对象。
  dtype ：data-type, 可选
  返回array的数据类型;默认值:float。
  count ：int, 可选
  要阅读的条目数。-1表示缓冲区中的所有数据。
  offset ：int, 可选
  从这个偏移量(以字节为单位)开始读取缓冲区;默认值:0

>>> s = b'hello world'
>>> np.frombuffer(s,dtype='S1',count=5,offset=6)
array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')
>>> np.frombuffer(b'\x01\x02',dtype=np.uint8)
array([1, 2], dtype=uint8)
>>> np.frombuffer(b'\x01\x02\x03\x04\x05',dtype=np.uint8,count=3)
array([1, 2, 3], dtype=uint8)

numpy.fromfile函数

• 格式: numpy.fromfile(file, dtype=float, count=-1, sep=’’, offset=0)
• 功能:从文本或二进制文件中的数据构造一个数组。
  读取已知数据类型的二进制数据以及解析简单格式化的文本文件的一种高效方法。使用tofile方法写入的数据可以使用此函数读取。

将原始数据保存到磁盘
>>> dt = np.dtype([('time',[('min',np.int64),('sec',np.int64)]),('temp',float)])>>> x = np.zeros((1,),dtype=dt)
>>> x['time']['min'] = 10; x['temp'] = 98.25
>>> x
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
>>> import tempfile
>>> fname = tempfile.mkstemp()[1]
>>> x.tofile(fname)
>>> np.save(fname,x)
>>> np.load(fname+'.npy')
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

numpy.fromfunction函数

• 格式: numpy.fromfunction(function, shape, *, dtype=<class ‘float’>, **kwargs)
• 功能: 通过在每个坐标上执行一个函数来构造一个数组。
  参数：

function ：callable
该函数使用N个参数调用，其中N是的秩 shape。
每个参数代表沿特定轴变化的数组坐标。
例如，如果shape 为(2, 2)，
则参数将为(2, 2)array([[0, 0], [1, 1]])
 和 array([[0, 1], [0, 1]])
shape ：(N,)个整数元组
输出数组的形状，它也确定传递给function的坐标数组的形状。
dtype：bool,可选
传递给function的坐标数组的数据类型。默认情况下dtype为float。

>>> np.fromfunction(lambda i,j: i == j,(3,3),dtype=int)
array([[ True, False, False],
       [False,  True, False],
       [False, False,  True]])
>>> np.fromfunction(lambda i,j: i+j,(3,3),dtype=int)
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])
>>> np.fromfunction(lambda i,j: i+j,(4,4),dtype=int)
array([[0, 1, 2, 3],
       [1, 2, 3, 4],
       [2, 3, 4, 5],
       [3, 4, 5, 6]])

numpy.fromiter函数

• 格式: numpy.fromiter(iterable, dtype, count=-1)
• 功能:
  参数：

iterable ：iterable object
提供数组数据的可迭代对象。
dtype ：data-type
返回数组的数据类型。
count：int, 可选
从iterable中读取的项目数。默认值为-1，表示读取所有数据

>>> iterable = (x*x for x in range(5))
>>> np.fromiter(iterable,float)
array([ 0.,  1.,  4.,  9., 16.])

numpy.fromstring函数

• 格式: numpy.fromstring(string, dtype=float, count=-1, sep=’’)
• 功能: 从字符串中的文本数据初始化的新一维数组。
  参数：

string ：str
包含数据的字符串。
dtype ：data-type, 可选
数组的数据类型；默认值：浮动。对于二进制输入数据，
数据必须完全采用这种格式。支持大多数内置数字类型，
并且可能支持扩展名类型。
1.18.0版中的新功能：复杂dtypes。
count ：int, 可选
dtype从数据中读取此数量的元素。如果为负（默认值），
则将根据数据的长度确定计数。
sep ：str, 可选
在数据中分隔数字的字符串;
元素之间的额外空格也会被忽略。
自1.14版本以来已弃用:传递sep= ''(默认值)是已弃用的，
因为它将触发此函数的已弃用二进制模式。
这种模式将字符串解释为二进制字节，
而不是使用十进制数字的ASCII文本，
这种操作更好地拼写为frombuffer(string、dtype、count)。
如果string包含unicode文本，
fromstring的二进制模式将首先使用utf-8 (python 3)
或默认编码(python 2)将其编码为字节，
这两种编码都不会产生正常的结果

>>> np.fromstring('1 2',dtype=int,sep=' ')
array([1, 2])
>>> np.fromstring('1,2',dtype=int,sep=',')
array([1, 2])

numpy.loadtxt函数

• 格式: numpy.loadtxt(fname, dtype=, comments=’#’, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=‘bytes’, max_rows=None)
• 功能: 从文本文件加载数据。
  参数 ：

fname：file, str,或 pathlib.Path
要读取的文件，文件名或生成器。 
如果文件扩展名是.gz或.bz2，
则首先将文件解压缩。 请注意，
生成器应返回字节字符串。
dtype：data-type, 可选
结果数组的数据类型； 默认值：float。
 如果这是结构化数据类型，
则结果数组将为一维，并且每一行将被解释为数组的元素。 
在这种情况下，使用的列数必须与数据类型中的字段数匹配。
comments：str 或 str的sequence, 可选
用于指示注释开始的字符或字符列表。 无表示无评论。 
为了向后兼容，字节字符串将被解码为“latin1”。
 默认值为“#”。
delimiter：str, 可选
用于分隔值的字符串。 为了向后兼容，
字节字符串将被解码为“latin1”。 默认为空格。
converters：dict, 可选
将列号映射到函数的字典，
该函数会将列字符串解析为所需的值。 例如，
如果第0列是日期字符串：
converters = {0：datestr2num}。
 转换器也可以用于提供缺失数据的默认值
（但另请参见 genfromtxt）：
converters = {3：lambda s：float（s.strip（）或0）}。
 默认值：None。
skiprows：int, 可选
跳过第一行，包括注释； 默认值：0
usecols：int 或 sequence, 可选
要读取的列，第一列为0。 例如，usecols =（1,4,5）
将提取第二，第五和第六列。 默认值为“None”，
将导致读取所有列。在版本1.11.0中进行了更改：
当必须读取单个列时，可以使用整数而不是元组。 
例如，usecols = 3读取第四列的方式与
usecols =（3，）相同。
unpack：bool, 可选
如果为True，则对返回的数组进行转置，
以便可以使用x，y，z = loadtxt（...）解压缩参数。 
与结构化数据类型一起使用时，将为每个字段返回数组。 
默认值为False。
ndmin：int, 可选
返回的数组将至少具有ndmin维。 否则，将挤压一维轴。
 合法值：0（默认），1或2。
1.6.0版中的新功能。
encoding：str,可选
用于解码输入文件的编码。 不适用于输入流。
 特殊值 ‘bytes’可实现向后兼容的解决方法，
可确保您尽可能接收字节数组作为结果，
并将“latin1”编码的字符串传递给转换器。
 覆盖此值以接收unicode数组，
并将字符串作为输入传递给转换器。 
如果设置为None，则使用系统默认值。 
默认值为 ‘bytes’。
1.14.0版中的新功能。
max_rows：int, 可选
在行数之后读取max_rows内容行。 默认为读取所有行。

注意: 文本里面要用空格隔开，而不是逗号隔开

>>> import os
>>> np.loadtxt(os.path.abspath(".")+"/materials/data.txt")
array([1., 2., 3., 4., 5., 6., 7.])
>>> from io import StringIO #StringIO 具有一个像file对象的行为,但是只能读取一边
>>> c = StringIO("0 1\n 2 3")
>>> np.loadtxt(c) #loadtxt函数可以处理字符串路径也可以处理file对象
array([[0., 1.],
       [2., 3.]])
>>> s = StringIO('10.01 21.23- \n 19.22 53.2\n17.57- 63.93')>>> def conv(fld):...     return -float(fld[:-1] if fld.endswith(b'-') else fld)
... 
>>> np.loadtxt(s,converters={0: conv,1: conv})
array([[-10.01, -21.23],
       [-19.22, -53.2 ],
       [-17.57, -63.93]])
>>> np.loadtxt(s,converters={0: lambda fld:float(fld[:-1] if fld.endswith(b'-') else fld),1: conv})
array([[ 19.22, -53.2 ],
       [ 17.57, -63.93]])

numpy.core.records.fromarrays函数

• 格式: numpy.core.records.fromarrays(arrayList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None)
• 功能: 从（flat）数组列表创建记录数组
  参数 ：

arrayList ：list 或 tuple
类数组对象的列表（例如，列表，元组和ndarray）。
dtype ：data-type, 可选
所有数组的有效dtype
shape ：int 或 ints的tuple, 可选
所得数组的Shape。 如果未提供，则从arrayList [0]推断。
formats, names, titles, aligned, byteorder：
如果dtype为None，
则将这些参数传递给numpy.format_parser以构造dtype。 
有关详细文档，请参见该功能。

>>> x1 = np.array([1,2,3,4])
>>> x2 = np.array(['a','dd','xyz','12'])
>>> x3 = np.array([1.1,2,3,4])
>>> r = np.core.records.fromarrays([x1,x2,x3],names="a,b,c")
>>> r[1]
(2, 'dd', 2.)
>>> x1[1] = 34
>>> r.a
array([1, 2, 3, 4])
>>> 
>>> x1 = np.array([1,2,3,4])
>>> x2 = np.array(['a','dd','xyz','12'])
>>> x3 = np.array([1.1,2,3,4])
>>> r = np.core.records.fromarrays([x1,x2,x3],dtype=np.dtype([('a',np.int32),('b','S3'),('c',np.float32)]))
>>> r
rec.array([(1, b'a', 1.1), (2, b'dd', 2. ), (3, b'xyz', 3. ),
           (4, b'12', 4. )],
          dtype=[('a', '<i4'), ('b', 'S3'), ('c', '<f4')])

numpy.core.records.fromrecords函数

• 格式: numpy.core.records.fromrecords(recList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None)
• 功能: 从文本形式的记录列表创建一个rearray。
  参数 ：

recList ：sequence
同一字段中的数据可能是异构的-它们将被提升为最高数据类型。
dtype ：data-type, 可选
所有数组的有效dtype
shape ：int 或 int的tuple, 可选
formats, names, titles, aligned, byteorder：
如果dtype为None，
则将这些参数传递给numpy.format_parser以构造dtype。 
有关详细文档，请参见该功能。 
如果format和dtype均为None，
则将自动检测格式。 
使用元组的list而不是列表的list可以加快处理速度。

>>> r = np.core.records.fromrecords([(456,'dbe',1.2),(1,'de',1.3)],names='col1,col2,col3')
>>> r[0]
(456, 'dbe', 1.2)
>>> r.col1
array([456,   1])
>>> r.col2
array(['dbe', 'de'], dtype='<U3')
>>> import pickle
>>> pickle.loads(pickle.dumps(r))
rec.array([(456, 'dbe', 1.2), (  1, 'de', 1.3)],
          dtype=[('col1', '<i8'), ('col2', '<U3'), ('col3', '<f8')])
>>> 

numpy.core.records.fromstring函数

• 格式: numpy.core.records.fromstring(datastring, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None)
• 功能: 根据二进制数据创建记录数组
  参数 ：

datastring ：bytes-like
二进制数据缓冲区
dtype ：data-type, 可选
shape ：int 或int的tuple, 可选
每个数组的形状。
offset ：int, 可选
在缓冲区中开始读取的位置。
formats, names, titles, aligned, byteorder：
如果dtype为None，
则将这些参数传递给numpy.format_parser以构造dtype。

>>> a = b'\x01\x02\x03abc'
>>> np.core.records.fromstring(a,dtype='u1,u1,u1,S3')
rec.array([(1, 2, 3, b'abc')],
          dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')])

numpy.core.records.fromfile函数

• 格式: numpy.core.records.fromfile(fd, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None)
• 功能: 根据二进制文件数据创建数组
  参数 ：

fd：str 或 file type
如果file是字符串或类似路径的对象，
则将打开该文件，否则假定它是文件对象。 
文件对象必须支持随机访问
（即，它必须具有tell 和 seek方法）。
dtype ：data-type, 可选
所有数组的有效dtype
shape ：int 或 int的tuple，可选
offset ：int, 可选
在文件中开始读取的位置。
formats, names, titles, aligned, byteorder：
如果dtype为None，
则将这些参数传递给numpy.format_parser以构造dtype。

>>> from tempfile import TemporaryFile
>>> a = np.empty(10,dtype='f8,i4,a5')
>>> a[5] = (0.5,10,'abcde')
>>> fd = TemporaryFile()
>>> a = a.newbyteorder('<')
>>> a.tofile(fd)
>>> _ = fd.seek(0)
>>> r = np.core.records.fromfile(fd,formats='f8,i4,a5',shape=10,byteorder='<')
>>> r[5]
(0.5, 10, b'abcde')
>>> r.shape
(10,)

numpy.arange函数

• 格式: numpy.arange([start, ]stop, [step, ]dtype=None)
• 功能: 返回给定间隔内的均匀间隔的值。
  参数 ：

start ：number, 可选
stop ：number
间隔结束。 该间隔不包括该值，除非在某些情况下，
step不是整数，并且浮点舍入会影响out的长度。
step ：number, 可选
值之间的间距。 对于任何输出out，
这是两个相邻值out[i+1] - out[i]之间的距离。 
默认步长为1。如果将step指定为位置参数，
则还必须指定start。
dtype ：dtype
输出数组的类型。 如果未给出dtype，
则从其他输入参数推断数据类型。

>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([0., 1., 2.])
>>> np.arange(3,7,2)
array([3, 5])

Other知识

内置函数issubclass函数

• 格式: issubclass(class,classinfo)
• 作用: 如果class是classinfo的子类返回True，否则返回False

>>> a = np.array([(1.0,2),(3.0,4)],dtype='f4,i4').view(np.recarray)
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True

numpy.recarray函数

• 暂时忽略

copy模块的deecopy函数

#浅拷贝
>>> a = np.array([1,'m',[2,3,4]],dtype=object)
>>> b = np.copy(a)
>>> b[2][0] = 10
>>> b
array([1, 'm', list([10, 3, 4])], dtype=object)
>>> a
array([1, 'm', list([10, 3, 4])], dtype=object)
#深拷贝
>>> a = np.array([1,'m',[2,3,4]],dtype=object)
>>> c = copy.deepcopy(a)
>>> c[2][0] = 10
>>> c
array([1, 'm', list([10, 3, 4])], dtype=object)
>>> a
array([1, 'm', list([2, 3, 4])], dtype=object)

lambda

• 格式: lambda 值:执行体
• 功能: 可以理解为一个匿名函数

>>> g = lambda x:x+1
>>> g(1)
2
>>> g(2)
3
>>> def g(x):
...     return x+1
... 
>>> g(1)
2
>>> g(2)
3

filter函数

• 格式: filter(function,iterable)
• 功能: 过滤掉不符合条件的元素，返回一个filter对象
  其中第一个参数为函数，第二个参数为序列,查看值需要提前将filter转换为list,但是无法转换为ndarray

>>> def is_ood(n):
...     return n%2 == 1
... 
>>> newlist = filter(is_ood,[1,2,3,4,5,6,7,8,9,10])
>>> newlist
<filter object at 0x7fb774ef1820>
>>> newlist = list(newlist)
>>> newlist
[1, 3, 5, 7, 9]
>>> newlist = filter(lambda x:x%2==1,[1,2,3,4,5,6,7,8,9,10])
>>> newlist = list(newlist)
>>> newlist
[1, 3, 5, 7, 9]

map函数

• 格式: map(function, iterable, …)
• 功能: 对函数处理的数映射到原来元素位置上

>>> newone = map(lambda x:x**2,[1,2,3,4,5])
>>> newone =list(newone)
>>> newone
[1, 4, 9, 16, 25]
>>> newone = map(lambda x,y:x*y,[1,2,3,4,5],[5,4,3,2,1])
>>> newone = list(newone)
>>> newone
[5, 8, 9, 8, 5]

for…in…if

• 结构: newlist = [x for x in 列表 if x%2 == 0]
• 功能: 对列表进行过滤，产生一个新的列表

>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> newlist = [x for x in a ]
>>> newlist
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> newlist = [x for x in a if x%2 != 0]
>>> newlist
[1, 3, 5, 7, 9]

工作路径(os模块)

• 获取当前工作路径: os.getcwd()或os.path.abspath(".")或者os.path.abspath(os.curdir)
• 将文件添加到工作路径下: os.path.abspath(“filename”)
• 获取父级工作目录: os.path.abspath("…")
• 进入子目录: os.chdir(“子目录名称”)
• 退出子目录: os.chdir("…")
• 组合工作路径: os.path.join(‘file1’,‘file2’,‘file3’)
• 获得目录下所有的文件:
  os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
  参数:

       top -- 根目录下的每一个文件夹(包含它自己), 产生3-元组 (dirpath, dirnames, filenames)【文件夹路径,文件夹名字, 文件名】。
       topdown --可选，
         为True或者没有指定, 一个目录的的3-元组将比它的任何子文件夹的3-元组先产生 (目录自上而下)。
         如果topdown为 False, 一个目录的3-元组将比它的任何子文件夹的3-元组后产生 (目录自下而上)。
       onerror -- 可选，是一个函数; 它调用时有一个参数, 一个OSError实例。报告这错误后，继续walk,或者抛出exception终止walk。
       followlinks -- 设置为 true，则通过软链接访问目录。
  

>>> for root,dirs,files in os.walk(os.getcwd()):
...     print('----------')
...     print(root)
...     print(dirs)
...     print(files)
...     print()
... 
----------
/home/user/PythonFires/学习文献/Numpy
['materials', 'images']
['Numpy1.md', 'Numpy2.md', 'math_every.md', 'math.md']
----------
/home/user/PythonFires/学习文献/Numpy/materials
[]
['data.txt']