python中一些数据处理库

numpy

Numpy是Python的一个很重要的第三方库，很多其他科学计算的第三方库都是以Numpy为基础建立的。Numpy的一个重要特性是它的数组计算。

numpy中的多维数组成为ndarray
numpy中的arange()函数可创建一个一维向量
numpy中利用array()创建多维数组
数组中的数据可以定义类型

np.arange（7，dtype='float16'）

1、一维数组切片
2、处理数组形状
3、堆叠数组，将多个数组堆成一个数组
4、拆分数组
5、numpy数组的属性
6、数组转换
7、用numpy进行线性代数运算
- 子程序包numpy.linalg中的inv()函数就是用来求矩阵的逆
- 用numpy解线性方程组
8、numpy随机数 

numpy数组

数组的一些属性

1、从列表产生数组：
使用numpy中的array函数将列表数据转换成数组

import numpy as np
lst = [0, 1, 2, 3]
a = array(lst)
a
array([0, 1, 2, 3])

2、数组属性

• 使用type函数查看数组的类型

• 使用a.dtpye()查看数组中数据的类型

• 使用a.shape查看数组的形状

• 使用a.ndim查看数组的维数

3、数组索引与切片

切片在内存中使用的是引用机制，引用机制意味着，Python并没有为 b 分配新的空间来存储它的值，而是让 b 指向了 a 所分配的内存空间，因此，改变 b 会改变 a 的值：

a = array([0,1,2,3,4])
b = a[2:4]
print b
[2 3]
b[0] = 10
a
array([ 0,  1, 10,  3,  4])

而这种现象在列表中并不会出现：

a = [1,2,3,4,5]
b = a[2:3]
b[0] = 13234
print a
[1, 2, 3, 4, 5]

这样做的好处在于，对于很大的数组，不用大量复制多余的值，节约了空间。

缺点在于，可能出现改变一个值改变另一个值的情况。

一个解决方法是使用copy()方法产生一个复制，这个复制会申请新的内存：

a = array([0,1,2,3,4])
b = a[2:4].copy()
b[0] = 10
a
array([0, 1, 2, 3, 4])array([0

数组的类型

1、复数数组

a = array([1 + 1j, 2, 3, 4])
a.dtype
dtype('complex128')

2、指定数组类型
我们可以在构建的时候指定类型：

a = array([0,1.0,2,3],
         dtype=float32)

0-255 的数字可以表示ASCⅡ码，我们可以用 ord 函数来查看字符的ASCⅡ码值：
3、任意数据类型

a = array([1,1.2,'hello', [10,20,30]], 
          dtype=object)

3、numpy中数组的类型

类型转换

1、asarray 函数，转换数组的类型：

asarray 不会修改原来数组的值，但当类型相同的时候，asarray 并不会产生新的对象，而是使用同一个引用。
这么做的好处在与，asarray 不仅可以作用于数组，还可以将其他类型转化为数组。

a = array([1.5, -3], dtype=float32)
asarray(a, dtype=float64)

有些时候为了保证我们的输入值是数组，我们需要将其使用 asarray 转化，当它已经是数组的时候，并不会产生新的对象，这样保证了效率。

2、astype 方法返回一个新数组。

astype也不会改变原来数组的值，另外，astype 总是返回原来数组的一份复制，即使转换的类型是相同的：

3、view 方法
view 会将 a 在内存中的表示看成是 uint8 进行解析：

a = array((1,2,3,4), dtype=int32)
a
array([1, 2, 3, 4])
b = a.view(uint8)
b
array([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0], dtype=uint8)
a[0] = 2**30
a
array([1073741824,          2,          3,          4])
b
array([ 0,  0,  0, 64,  2,  0,  0,  0,  3,  0,  0,  0,  4,  0,  0,  0], dtype=uint8)

修改 a 会修改 b 的值，因为共用一块内存

数组方法

1、求和

2、求积

3、最大，最小值

4、均值，标准差

5、clip 方法
将数值限制在某个范围：

6、ptp 方法
计算最大值和最小值之差

7、round 方法
近似，默认到整数

数组排序

1、sort排序
返回的结果是从小到大排列的
2、argsort 函数
argsort 返回从小到大的排列在数组中的索引位置

对于多维数组，sort方法默认沿着最后一维开始排序：

3、searchsorted 函数
searchsorted(sorted_array, values)

searchsorted 接受两个参数，其中，第一个必需是已排序的数组。

sorted_array = linspace(0,1,5)
values = array([.1,.8,.3,.12,.5,.25])
searchsorted(sorted_array, values)
array([1, 4, 2, 1, 2, 1], dtype=int64)

数组属性方法总结

1 基本属性
a.dtype 数组元素类型 float32,uint8,…
a.shape 数组形状 (m,n,o,…)
a.size 数组元素数
a.itemsize 每个元素占字节数
a.nbytes 所有元素占的字节
a.ndim 数组维度
2 形状相关
a.flat 所有元素的迭代器
a.flatten() 返回一个1维数组的复制
a.ravel() 返回一个1维数组，高效
a.resize(new_size) 改变形状
a.swapaxes(axis1, axis2) 交换两个维度的位置
a.transpose(*axex) 交换所有维度的位置
a.T 转置，a.transpose()
a.squeeze() 去除所有长度为1的维度
3 填充复制
a.copy() 返回数组的一个复制
a.fill(value) 将数组的元组设置为特定值
4 转化
a.tolist() 将数组转化为列表
a.tostring() 转换为字符串
a.astype(dtype) 转化为指定类型
a.byteswap(False) 转换大小字节序
a.view(type_or_dtype) 生成一个使用相同内存，但使用不同的表示方法的数组
5 复数
a.imag 虚部
a.real 实部
a.conjugate() 复共轭
a.conj() 复共轭（缩写）
6 保存
a.dump(file) 将二进制数据存在file中
a.dump() 将二进制数据表示成字符串
a.tofile(fid, sep="",format="%s") 格式化ASCⅡ码写入文件
7 查找排序
a.nonzero() 返回所有非零元素的索引
a.sort(axis=-1) 沿某个轴排序
a.argsort(axis=-1) 沿某个轴，返回按排序的索引
a.searchsorted(b) 返回将b中元素插入a后能保持有序的索引值
8 元素数学操作
a.clip(low, high) 将数值限制在一定范围内
a.round(decimals=0) 近似到指定精度
a.cumsum(axis=None) 累加和
a.cumprod(axis=None) 累乘积
9 约简操作
a.sum(axis=None) 求和
a.prod(axis=None) 求积
a.min(axis=None) 最小值
a.max(axis=None) 最大值
a.argmin(axis=None) 最小值索引
a.argmax(axis=None) 最大值索引
a.ptp(axis=None) 最大值减最小值
a.mean(axis=None) 平均值
a.std(axis=None) 标准差
a.var(axis=None) 方差
a.any(axis=None) 只要有一个不为0，返回真，逻辑或
a.all(axis=None) 所有都不为0，返回真，逻辑与

矩阵

使用 mat 方法将 2 维数组转化为矩阵

import numpy as np
a = np.array([[1,2,4],
              [2,5,3], 
              [7,8,9]])
A = np.mat(a)
A

matrix([[1, 2, 4],
        [2, 5, 3],
        [7, 8, 9]])matrix(

1、矩阵与向量的乘法：

2、A.I 表示 A 矩阵的逆矩阵：

函数

一般函数
In [1]:
import numpy as np
三角函数
sin(x)
cos(x)
tan(x)
sinh(x)
conh(x)
tanh(x)
arccos(x)
arctan(x)
arcsin(x)
arccosh(x)
arctanh(x)
arcsinh(x)
arctan2(x,y)

arctan2(x,y) 返回 arctan(x/y) 。

向量操作
dot(x,y)
inner(x,y)
cross(x,y)
vdot(x,y)
outer(x,y)
kron(x,y)
tensordot(x,y[,axis])
其他操作
exp(x)
log(x)
log10(x)
sqrt(x)
absolute(x)
conjugate(x)
negative(x)
ceil(x)
floor(x)
fabs(x)
hypot(x)
fmod(x)
maximum(x,y)
minimum(x,y)

hypot 返回对应点 (x,y) 到原点的距离。

In [2]:
x = np.array([1,2,3])
y = np.array([4,5,6])
np.hypot(x,y)
Out[2]:
array([ 4.12310563, 5.38516481, 6.70820393])
类型处理
iscomplexobj
iscomplex
isrealobj
isreal
imag
real
real_if_close
isscalar
isneginf
isposinf
isinf
isfinite
isnan
nan_to_num
common_type
typename

正无穷：

In [3]:
np.inf
Out[3]:
inf
负无穷：

In [4]:
-np.inf
Out[4]:
-inf
非法值（Not a number）：

In [5]:
np.nan
Out[5]:
nan
检查是否为无穷：

In [6]:
np.isinf(1.0)
Out[6]:
False
In [7]:
np.isinf(np.inf)
Out[7]:
True
In [8]:
np.isinf(-np.inf)
Out[8]:
True
非法值：

In [9]:
np.array([0]) / 0.0
c:\Miniconda\lib\site-packages\IPython\kernel_main_.py:1: RuntimeWarning: invalid value encountered in divide
if name == ‘main’:
Out[9]:
array([ nan])
这并不会报错，而是返回一个非法值。

只有 0/0 会得到 nan，非0值除以0会得到无穷：

In [10]:
a = np.arange(5.0)
b = a / 0.0
b
c:\Miniconda\lib\site-packages\IPython\kernel_main_.py:2: RuntimeWarning: divide by zero encountered in divide
from IPython.kernel.zmq import kernelapp as app
c:\Miniconda\lib\site-packages\IPython\kernel_main_.py:2: RuntimeWarning: invalid value encountered in divide
from IPython.kernel.zmq import kernelapp as app
Out[10]:
array([ nan, inf, inf, inf, inf])
nan 与任何数进行比较都是 False：

In [11]:
b == np.nan
Out[11]:
array([False, False, False, False, False], dtype=bool)
想要找出 nan 值需要使用 isnan：

In [12]:
np.isnan(b)
Out[12]:
array([ True, False, False, False, False], dtype=bool)
修改形状
atleast_1d
atleast_2d
atleast_3d
expand_dims
apply_over_axes
apply_along_axis
hstack
vstack
dstack
column_stack
hsplit
vsplit
dsplit
split
squeeze
其他有用函数
fix
mod
amax
amin
ptp
sum
cumsum
prod
cumprod
diff
angle

unwrap
sort_complex
trim_zeros
fliplr
flipud
rot90
diag
eye
select
extract
insert

roots
poly
any
all
disp
unique
nansum
nanmax
nanargmax
nanargmin
nanmin

nan 开头的函数会进行相应的操作，但是忽略 nan 值。

数组广播机制

数组读写

1、从文本中读取数组
使用 loadtxt 方法：

data = np.loadtxt('myfile.txt')
data

对于逗号分隔的文件（通常为.csv格式），loadtxt 函数也可以读这样的文件，只需要制定分割符的参数即可：

data = np.loadtxt('myfile.txt', delimiter=',')
data

loadtxt 函数
loadtxt(fname, dtype=<type ‘float’>,
comments=’#’, delimiter=None,
converters=None, skiprows=0,
usecols=None, unpack=False, ndmin=0)

loadtxt 有很多可选参数，其中 delimiter 就是刚才用到的分隔符参数。
skiprows 参数表示忽略开头的行数，可以用来读写含有标题的文本

%%writefile myfile.txt
X Y Z MAG ANG
2.1 2.3 3.2 1.3 3.1
6.1 3.1 4.2 2.3 1.8

np.loadtxt('myfile.txt', skiprows=1)
array([[ 2.1,  2.3,  3.2,  1.3,  3.1],
       [ 6.1,  3.1,  4.2,  2.3,  1.8]])

data = np.loadtxt('myfile.txt', 
                  skiprows=1,         #忽略第一行
                  dtype=np.int,      #数组类型
                  delimiter=',',     #逗号分割
                  usecols=(0,1,2,4), #指定使用哪几列数据
                  comments='%'       #百分号为注释符
                 )

Scipy

Scipy 由不同科学计算领域的子模块组成：

子模块 描述
cluster 聚类算法
constants 物理数学常数
fftpack 快速傅里叶变换
integrate 积分和常微分方程求解
interpolate 插值
io 输入输出
linalg 线性代数
odr 正交距离回归
optimize 优化和求根
signal 信号处理
sparse 稀疏矩阵
spatial 空间数据结构和算法
special 特殊方程
stats 统计分布和函数
weave C/C++ 积分