数组类型
In [1]:
from numpy import *
之前已经看过整数数组和布尔数组，除此之外还有浮点数数组和复数数组。
复数数组
产生一个复数数组：
In [2]:
a = array([1 + 1j, 2, 3, 4])
Python会自动判断数组的类型：
In [3]:
a.dtype
Out[3]:
dtype('complex128')
对于复数我们可以查看它的实部和虚部：
In [4]:
a.real
Out[4]:
array([ 1., 2., 3., 4.])
In [5]:
a.imag
Out[5]:
array([ 1., 0., 0., 0.])
还可以设置它们的值：
In [6]:
a.imag = [1,2,3,4]
查看 a：
In [7]:
a
Out[7]:
array([ 1.+1.j, 2.+2.j, 3.+3.j, 4.+4.j])
查看复共轭：
In [8]:
a.conj()
Out[8]:
array([ 1.-1.j, 2.-2.j, 3.-3.j, 4.-4.j])
事实上，这些属性方法可以用在浮点数或者整数数组上：
In [9]:
a = array([0.,1,2,3])
a.dtype
Out[9]:
dtype('float64')
In [10]:
a.real
Out[10]:
array([ 0., 1., 2., 3.])
In [11]:
a.imag
Out[11]:
array([ 0., 0., 0., 0.])
In [12]:
a.conj()
Out[12]:
array([ 0., 1., 2., 3.])
但这里，虚部是只读的，并不能修改它的值：
In [13]:
# 会报错
a.imag = [1,2,3,4]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-13-3db28f506ec9> in <module>()
1 # 会报错
----> 2 a.imag = [1,2,3,4]
TypeError: array does not have imaginary part to set
指定数组类型
之前已经知道，构建数组的时候，数组会根据传入的内容自动判断类型：
In [14]:
a = array([0,1.0,2,3])
对于浮点数，默认为双精度：
In [15]:
a.dtype
Out[15]:
dtype('float64')
查看所用字节（8 bytes * 4）：
In [16]:
a.nbytes
Out[16]:
32
当然，我们也可以在构建的时候指定类型：
In [17]:
a = array([0,1.0,2,3],
dtype=float32)
此时类型为单精度浮点数：
In [18]:
a.dtype
Out[18]:
dtype('float32')
查看所用字节（4 bytes * 4）：
In [19]:
a.nbytes
Out[19]:
16
除此之外，还可以指定有无符号，例如无符号整数：
In [20]:
a = array([0,1,2,3],
dtype=uint8)
a.dtype
Out[20]:
dtype('uint8')
uint8 只使用一个字节，表示 0 到 255 的整数。
还可以从二进制数据中读取。
先写入二进制数据：
In [21]:
a = array([102,111,212],
dtype=uint8)
a.tofile('foo.dat')
从数据中读入，要指定类型：
In [22]:
b = frombuffer('foo',
dtype=uint8)
b
Out[22]:
array([102, 111, 111], dtype=uint8)
清理数据文件：
In [23]:
import os
os.remove('foo.dat')
0-255 的数字可以表示ASCⅡ码，我们可以用 ord 函数来查看字符的ASCⅡ码值：
In [24]:
ord('f')
Out[24]:
102
In [25]:
ord('S')
Out[25]:
83
Numpy 类型
具体如下：
| 基本类型 | 可用的Numpy类型 | 备注 |
|---|---|---|
| 布尔型 | bool |
占1个字节 |
| 整型 | int8, int16, int32, int64, int128, int |
int 跟C语言中的 long 一样大 |
| 无符号整型 | uint8, uint16, uint32, uint64, uint128, uint |
uint 跟C语言中的 unsigned long 一样大 |
| 浮点数 | float16, float32, float64, float, longfloat |
默认为双精度 float64 ，longfloat 精度大小与系统有关 |
| 复数 | complex64, complex128, complex, longcomplex |
默认为 complex128 ，即实部虚部都为双精度 |
| 字符串 | string, unicode |
可以使用 dtype=S4 表示一个4字节字符串的数组 |
| 对象 | object |
数组中可以使用任意值 |
| Records | void |
|
| 时间 | datetime64, timedelta64 |
任意类型的数组：
In [26]:
a = array([1,1.2,'hello', [10,20,30]],
dtype=object)
乘法：
In [27]:
a * 2
Out[27]:
array([2, 2.4, 'hellohello', [10, 20, 30, 10, 20, 30]], dtype=object)
类型转换
转换数组的类型：
In [28]:
a = array([1.5, -3],
dtype=float32)
a
Out[28]:
array([ 1.5, -3\. ], dtype=float32)
asarray 函数
使用 asarray 函数：
In [29]:
asarray(a, dtype=float64)
Out[29]:
array([ 1.5, -3\. ])
In [30]:
asarray(a, dtype=uint8)
Out[30]:
array([ 1, 253], dtype=uint8)
asarray 不会修改原来数组的值：
In [31]:
a
Out[31]:
array([ 1.5, -3\. ], dtype=float32)
但当类型相同的时候，asarray 并不会产生新的对象，而是使用同一个引用：
In [32]:
b = asarray(a, dtype=float32)
In [33]:
b is a
Out[33]:
True
这么做的好处在与，asarray 不仅可以作用于数组，还可以将其他类型转化为数组。
有些时候为了保证我们的输入值是数组，我们需要将其使用 asarray 转化，当它已经是数组的时候，并不会产生新的对象，这样保证了效率。
In [34]:
asarray([1,2,3,4])
Out[34]:
array([1, 2, 3, 4])
astype 方法
astype 方法返回一个新数组：
In [35]:
a.astype(float64)
Out[35]:
array([ 1.5, -3\. ])
In [36]:
a.astype(uint8)
Out[36]:
array([ 1, 253], dtype=uint8)
astype也不会改变原来数组的值：
In [37]:
a
Out[37]:
array([ 1.5, -3\. ], dtype=float32)
另外，astype 总是返回原来数组的一份复制，即使转换的类型是相同的：
In [38]:
b = a.astype(float32)
print a
print b
[ 1.5 -3\. ]
[ 1.5 -3\. ]
In [39]:
a is b
Out[39]:
False
view 方法
In [40]:
a = array((1,2,3,4), dtype=int32)
a
Out[40]:
array([1, 2, 3, 4])
view 会将 a 在内存中的表示看成是 uint8 进行解析：
In [41]:
b = a.view(uint8)
b
Out[41]:
array([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0], dtype=uint8)
In [42]:
a[0] = 2**30
a
Out[42]:
array([1073741824, 2, 3, 4])
修改 a 会修改 b 的值，因为共用一块内存：
In [43]:
b
Out[43]:
array([ 0, 0, 0, 64, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0], dtype=uint8)
