Numpy 知识点总览

1.Numpy可以做什么

数组的算术和逻辑运算
傅里叶变换和用于图形操作的例程
与线性代数有关的操作，NumPy拥有线性代数和随机数生成的内置函数

2.安装

pip install numpy
启用NumPy的最佳方法是使用特定于您的操作系统的可安装的二进制包。这些二进制包含SciPy技术栈（NumPy,SciPy,matplotlib,IPython,SymPy以及Python核心自带的其他包）
比如：Anaconda  是一个带有 SciPy 技术栈的免费 Python 发行版。 它也可用于 Linux 和 Mac.

3.Numpy-Ndarray对象

    ndarray对象由计算机内存中的一维连续区域组成，带有将每个元素映射到内存块中某个位置的索引方案，内存块以按行（c风格）或按列（Fortran或matlab风格）的方式保存元素
    Numpy中定义的最重要的对象是称为ndarray的N维数组类型。她描述相同类型的元素集合。可以使用基于零的索引访问集合中项目
    ndarray中的每个元素在内存中使用相同大小的块。ndarray中的每个元素是数据类型对象的对象（称为dtype）

4.不明白     ndarray，数据类型对象（dtype）和数组标量类型之间的关系

5.基本的ndarray是使用numpy.array创建

      numpy.array(object,dtype=None,copy=True,order=C|F|A,subok=False,ndmin=0)    subok不理解,ndmin至少返回几维数组
      ndmin体现在列表的嵌套深度
      
6.
通过传入一个数组来创建
import numpy as np
a=np.array([1,2,3])
print(a)

自己推理一下多为数组的创建   可以看做列表的嵌套

7.numpy数据类型【内建类型】
 bool_    存储为一个字节的布尔值（正或假）int_
 intc    intp用于索引的整数
 int8  int16  int32  int64  uint8 uint16 uint32 uint64 float_ float16   float32
 float64  complex_   complex64  complex128
 NumPy数字类型是dtype(数据类型)对象的实例，每个对象具有唯一的特征。np.bool_
 
 
8.数据类型对象（dtype）,用于创建自己定义的一种数据类型【结构化的数据类型】
数据类型对象描述了对应于数组的固定内存块的解释
字节序-----大端，小端

-----------------------------------------------------------------------------------------------------

大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。

小端模式，是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

numpy.dtype(object,align,copy)   align如果为true,则向字段添加间隔，使其类似c的结构体 Copy? 生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。
#int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。  
xp:   dt=np.dtype('>i4')

8.1   声明了字段名称和相应的标量数据类型
        import numpy as np
        dt=np.dtype(['age',np.int8])    
        print(dt)
        
8.2定一个student的结构化数据类型，其中包含字符串字段name,整数字段age和浮点字段marks.此dtype应用于ndarray对象
import numpy as np
student = np.dtype([('name','S20'),('age','i1'),('marks','f4')])      #对于复杂的数据元素类型，在创建的时候以元组列表的形式
print(student)
a = np.array([('abc',21,50),('xyz',18,75)],dtype=student)
print(a)
每一个內建数据类型都有一个唯一定义它的字符代码:
'b'  'i'  'u'  'f'  'c'  'm'时间间隔  'M'日期时间   ‘O’Python   'S','a'字符串  'U':unicode    'V':原始数据（void）

9.  NumPy-数组属性
ndarray.shape      返回一个包含数组维度的元祖，也可以用于调整数组大小   a.shape=(3,2)    reshape(3,2)    几页几行几列
ndarray.ndim        返回数组的维数
numpy.arange(24)      创建等间隔的数组
numpy.itemsize        返回数组中每个元素的字节单位长度
numpy.flags       不懂

10.  NumPy数组创建例程   
    新的ndarray对象可以通过任何下列数组创建例程或使用低级ndarray构造函数构造。
    numpy.empty(shape,dtype=float,order='C')     所创建的数组元素是随机的，因为他们为初始化   shape用一个列表表示
    numpy.zeros(shape,dtype=float,order='C')    shape用一个元组表示        其中的dtype可以自己定义
    numpy.ones(shape,dtype=None,order='C')       shape用一个列表表示
    
11.NumPy 来自现有数据的数组
        numpy.asarray  这个例程对于将python序列化转换为ndarray非常有用
        numpy.asarray(a,dtype=None,order=None)
        将python中的数组，列表，等转为ndarray
        
        numpy.formbuffer(buffer,dtype=float,count=-1,offset=0)      缓冲区解释为一维数组   buffer 任何暴露缓冲区借口的对象  count 需要读取的数据数量，默认为-1，读取所有数据
        
        numpy.fromiter(iterable,dtype,count=-1)  从任何可迭代对象构建一个ndarray对象，返回一个新的一维数组
    
12.NumPy 来自数值范围的数组
    numpy.arange(start,stop,step,dtype)           创建包含给定范围内的等间隔值,dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型
    numpy.linspace(start,stop,num,endpoint,retstep,dtype)    num要生成的等间隔样例数量，默认为50     endpoint 序列中是否包含stop值，默认为true
                                                            retstep 如果为true ,返回样例，以及连续数数字之间的步长
    numpy.logspace(start,stop,num,endpoint,base,dtype)  返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。刻度的开始和结束端点是某个底数的幂，通常为 10。
                    a = np.logspace(1,10,num =  10,  base  =  2) 
13.NumPy 切片和索引
    ndarray对象的内容可以通过索引或切片来访问和修改，ndarray对象中的元素遵循基于零的索引，有三种可用的索引方法类型：字段访问，基本类型，高级索引
    
    基本切片是python中基本切片概念到n维的扩展，通过将start,stop和step参数传递给slice函数来构造一个python  slice对象
此slice对象被传递给数组来提取数组的一部分
import numpy as np
a = np.arange(10)
s = slice(2,7,2)  
print a[s]
通过将由冒号分隔的切片参数(start:stop:step)直接提供给ndarray对象，也可以获得相同的结果

对单个元素进行切片       a[5]
对始于索引的元素进行切片      a[2:]
对索引之间的元素进行切片     a[2:5]   返回下标2开始到5，单不包括索引5的3个元素

13.1 对多维数组进行切片   
    切片还可以包括省略号(...)，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的ndarray。
    
13.2 NumPy-高级索引    用于在多维数组中直接找到我们想要的额元素，索引从0开始
    x=np.array([[1,2,3],[4,5,6],[7,8,9]])
    y = x[[0,1,2],  [0,1,0]]  
    print y
    
    
    高级索引始终返回数据的副本，与此同时，切片只提供视图
    有两种类型的高级索引：整数和布尔值
    高级和基本索引可以通过使用切片 : 或省略号 ...  与索引数组组合
    
    切片与高级索引的不同
    
13.3  布尔索引
    这个例子使用了~(取补运算符)来过滤NaN。import numpy as np 
a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print a[~np.isnan(a)]

14  NumPy-广播
    处理不同形状的素组的能力。对数的算术运算通常在相应的元素上进行。如果两个阵列具有完全相同的形状，则这些操作被无缝执行
    一般来说，维度不同的数组，元素到元素的操作是不可能，然而，在NumPy中任然可以对形状不相同的数组进行操作，这就是广播的作用
    如果满足一下规则，可以进行广播：
    ndim较小的数组会在前面追加一个长度为 1 的维度。
    输出数组的每个维度的大小是输入数组该维度大小的最大值。
    如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它(T)。
    如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。
    
    如果上述规则产生有效结果，并且满足以下条件之一，
    
    那么数组被称为可广播的。数组拥有相同形状。
    数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
    数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。
    
    
    
    
15、  NumPy - 数组上的迭代
    
    NumPy 包含一个迭代器对象numpy.nditer  他是一个有效的多为迭代器对象，可以用于数组上进行迭代。数组中的每个元素可使用Python的标准Iterator接口来访问
    数组的转至  a.T
    
    迭代的顺序匹配数组的内容布局，而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。
    
    改变元素使用的顺序存储风格    
    强制nditer对象使用某种顺序：
    for x in np.nditer(a,order='C'):
        print(x)
        
    
    
15.1  修改数组的值
    nditer 对象由另一个可选参数 op_flags,其默认值为只读，但可以设置为读写或只写模式，这将允许使用此迭代器修改数组元素。
    
import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始数组是：'  
print a 
print  '\n'  
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x 
print  '修改后的数组是：'  
print a
    
15.2 广播迭代

    如果两个数组是可广播的，nditer组合对象能够同时迭代它们。 假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器(数组b被广播到a的大小)。
    
    可以用来配对
    
    import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '第一个数组：'  
print a 
print  '\n'  
print  '第二个数组：' 
b = np.array([1,  2,  3,  4], dtype =  int)  
print b 
print  '\n'  
print  '修改后的数组是：'  
for x,y in np.nditer([a,b]):  
    print ( "%d:%d"  %  (x,y))
    
16.数组的操作
16.1修改数组
NumPy包中有几个例程用于处理ndarray对象中的元素。他们可以分为以下类型
numpy.reshape(arr,newshape,order)      不改变数据的情况下修改形状
numpy.ndarray.flat    返回数组上的一维迭代器   a.flat[5] 行为类似python內建的迭代器
numpy.ndarray.flatten(order)  返回折叠为一维的数组副本，函数接受下列参数，
        order：'C' — 按行，'F' — 按列，'A' — 原顺序，'k' — 元素在内存中的出现顺序。

numpy.ravel(a,order)   这个函数返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同的数据类型。这个函数接受两个参数
        order：'C' — 按行，'F' — 按列，'A' — 原顺序，'k' — 元素在内存中的出现顺序。
        
16.2翻转数组
numpy.transpose(arr,axes)    这个函数翻转给定数组的维度，如果可能的话会返回一个视图。函数接受下列参数：
        numpy.transpose(arr,axes)   arr,要转置的数组     axes: 整数的列表，对应维度，通常所有维度都会翻转
numpy.ndarray.T     该属性属于ndarray类，行为类似于 numpy.transpose 
numpy.rollaxis(arr,axis,start)   该函数向后滚动特定的轴，直到一个特定位置。这个函数接受三个参数：
                    arr  输入数组     axis 要向后滚动的轴，其他轴的相对位置不会变
                    start 默认为零，表示完整的滚动，会滚动到特定位置。
numpy.swapaxes(arr,axis1,axis2)  该函数交换数组的两个轴
16.3修改维度

16.4数组的连接  
    numpy.concatenate((a1,a2,...),axis)  a1,a2 相同类型的数组序列  axis 沿着他连接数组的轴，默认为0
    numpy.stack(arrays,axis)  沿新轴连接数组序列。 axis 返回数组中的轴，输入数组沿着他来堆叠     注意与连接是不同的
    numpy.stack((a,b))   numpy.stack函数的变体，通过堆叠来生成水平的单个数组，当numpy.stack()中axis=1
    numpy.vstack(a,b)    numpy.stack函数的变体，通过堆叠来生成竖直的单个数组
                
16.5数组的分割
    numpy.split(ary,indices_or_sections,axis)  沿特定轴向将数组分割为子数组
            b = np.split(a,3)       b = np.split(a,[4,7])    为下标索引 如果是一个列表，表示指定的位置进行分割
    numpy.hsplit(ary,indices_or_sections)  是split()函数的特例，其中轴为1表示水平分割，无论输入数组的维度是什么
    numpy.vsplit(ary,indices_or_sections)  是split()函数的特例，其中轴为0表示竖直分割，无论输入的维度是什么。
    
16.6添加/删除元素
    numpy.resize(arr,shap)  函数返回指定大小的新数组，如果新数组的大小大于原始大小，则包含原始数组中的元素的重复副本
        np.resize(a,(3,2))
    numpy.append(arr,values,axis)      在出入数组的末尾添加值。附加操作不是原地的，而是分配新的数组。此外，输入数组的维度必须匹配否则将生成ValueError。
    numpy.insert(arr,obj,values,axis)   obj为在其之前插入值得索引，如果未提供axis,则输入数组会展开
    numpy.delete(arr,obj,axis)   返回从数组中删除指定子数组的新数组。与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。
                    obj  可以被切片，整数或者整数驻足，表明要从数组删除的子数组
                        print '删除第二列：'  
                        a = np.arange(12).reshape(3,4)
                        print np.delete(a,1,axis = 1)
    numpy.unique(arr, return_index, return_inverse, return_counts)  函数返回输入数组中的去重元素数组。该函数能够返回一个元组，包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型。
    
    
17.NumPy-位操作
    numpy.bitwise_and() 函数对输入数组中的整数二进制表示的相应位执行位于运算
    bin(a)  a的二进制     np.bitwise_and(13,17)
    np.binary_repr(10，width=8)函数返回给定宽度中十进制数的二进制表示
    numpy.bitwise_or()函数对输入数组中的整数的二进制表示的相应位执行位或运算
    
    np.invert()     计算输入数组中整数的位非结果。对于有符号整数，返回补码
        print '13 的位反转，其中 ndarray 的 dtype 是 uint8：' 
        print np.invert(np.array([13], dtype = np.uint8)) 
        print '\n'  
        # 比较 13 和 242 的二进制表示，我们发现了位的反转

        print '13 的二进制表示：' 
        print np.binary_repr(13, width = 8) 
        print '\n'  

        print '242 的二进制表示：' 
        print np.binary_repr(242, width = 8)
        
    numpy.left_shift(10,2)   函数将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等的0
        print '将 10 左移两位：' 
        print np.left_shift(10,2) 
        print '\n'  
    numpy.right_shift()函数将数组元素的二进制表示中的位向右移动到指定的位置，左侧附加相等的0
    
18.NumPy-字符串函数            用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作。
    numpy.char.add()             #np.char.add(['hello', 'hi'],[' abc', ' xyz'])
    numpy.char.multiply()        #np.char.multiply('hello',3)
    numpy.char.center()         #np.char.center('hello',20,fillchar='*')
    numpy.char.capitalize()     返回字符串的副本，其中第一个字母大写  np.char.capitalize('helloo world')
    numpy.char.title()            
    numpy.char.lower()
    numpy.char.upper()
    numpy.char.split()           返回输入字符串中的单词列表   print np.char.split ('YiibaiPoint,Hyderabad,Telangana', sep = ',')
    numpy.char.splitlines()      返回数组中元素的单词列表，以换行符分割
    numpy.char.strip()          函数返回数组的副本，其中元素移除了开头或结尾处的特定字符。
                         import numpy as np 
                            print np.char.strip('ashok arora','a') 
                            print np.char.strip(['arora','admin','java'],'a')
                            Python输出如下：shok aror
                                            ['ror' 'dmin' 'jav']
    numpy.char.join()             np.char.join([':','-'],['dmy','ymd'])      ['d:m:y' 'y-m-d']
    numpy.char.replace()          np.char.replace ('He is a good boy', 'is', 'was')
    numpy.char.encode('hello','utf8')
    numpy.char.decode(a,'utf8')
    
19.NumPy-算术运算
    a = np.array([0,30,45,50,90])
    print(np.sin(a*np.pi/180))       cos()     tan()   
    
    sin = np.sin(a*np.pi/180)
    print(sin)
    inv = np.arcsin(sin)   计算角度的反正弦，返回值以弧度为单位
    print(degress(inv))    通过转化为角度制来检查结果
    
    
    
    numpy.around(a,decimals) 返回四舍五入到所需精度的值  decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
    numpy.floor(a)     返回不大于输入参数的最大整数   即标量x 的下限是最大的整数i ，使得i <= x。 注意在Python中，向下取整总是从 0 舍入。
    numpy.ceil()  返回输入值得上限，即，标量x的上限是最小的整数i ，使得i> = x。
20.NumPy- 算术运算     add()     substract()   multiply()  divide()的输入数组必须具有相同的形状或符合数组广播规则
        numpy.reciprocal(b)    返回逐元素的倒数     由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告。
        numpy.power()    此函数将第一个输入数组中的元素作为定数没计算他与第二个输入数组中相应驻足中相应对数的幂
        numpy.mod()     此函数返回数组中相应元素的除法余数。函数 numpy.remainder()也产生相同的结果
        用于对含有复数的数组执行操作
            numpy.real()     numpy.imag()                           numpy.conj() 返回通过改变虚部的符号而获得的共轭复数
            numpy.angle()   返回复数参数的角度。 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。
            
21. NumPy - 统计函数  
    numpy.amin()  numpy.amax()    函数从给定数组中的元素沿指定轴返回最小值和最大值
                        np.amin(a,axis=0)
    numpy.ptp()   函数返回沿轴的值得范围（最大值-最小值）  如果不指定轴向，就会将所有的数展开进行计算，计算结果为一个整数，表示最小值与最大值之间的距离
    numpy.percentile(a,q,axis)     百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。
    numpy.median(a,axis)            定义将数组样本的上半部分与下半部分分开的值
    numpy.mean(a,axis)                   算术平均值是沿轴的元素的总和除以元素的数量。如果提供了轴，则沿轴计算
    numpy.average()             加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。  numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。
                    numpy.average([1,2,3,4],weights=[4,3,2,1],returned=True)
    标准差是与均值的偏差的平方的平均值的平方根。标准差公式如下：
        std = sqrt(mean((x-x.mean())**2))
    numpy.std(a)
    
    方差是偏差的平方的平均值，即 mean((x-x.mean())**2).也就是，标准差是方差的平分根
        numpy.var([1,2,3,4])
        
        
22.NumPy-排序，搜索和技术函数
    
        
    
    numpy.sort(a,axis,kind,order)     返回输入数组的排序副本。 kind（quicksort    mergesort    heapsort）   order 如果数组包含字段，则是要排序的字段
        dt = np.dtype([('name',  'S10'),('age',  int)]) 
a =     np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
        print np.sort(a, order =  'name')
        
    numpy.argsort(x)    函数对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数组的索引数组
    numpy.lexsort()    函数使用键序列执行间接排序。键可以看做是电子表格中国的一列
    numpy.argmax()   numpy.argmin()   分别返回沿给定轴返回最大和最小元素的索引，默认为行向
    numpy.nonaero()    返回输入数组中非零元素的索引，返回两个数组来表示索引
    numpy.where()     返回输入数组数组中国满足给定套件的元素的索引
    numpy.extract()    返回满足任何条件的元素
            condition = np.mod(x,2)  ==  0  
            print condition 
            print np.extract(condition, x)
            
23.  NumPy- 字节交换
    numpy.ndarray.byteswap()   函数在两个表示大端和小段之间切换
        print(a.byteswap(True)) #byteswap()函数通过传入true来原地交换
24.NumPy-副本和视图
     在执行函数时，其中一些返回输入数组的副本，而一些返回视图。当内容物理存储在别一个位置时，称为副本，另一方面，
    如果提供了相同内存内容的不同视图，我们 将其称为视图
    
24.1无复制
    简单的赋值不会创建数组对象的副本。相反，它使用原始数组的相同的id()来访问.
    id()返回python对象的通用表示服，类似于c中的指针。一个数组中的任何变化都反映在另一个数组上。
     例如，一个数组的形状改变也会改变另一个数组的形状。
     
24.2 NumPy拥有ndarray.view()方法，他是一个新的数组对象，并可查看原始数组的相同数组。与前一种情况不同，新数组的维度改变不会更改原始数据的维度
    a.view()   
    数组的切片也会创建视图
24.3 深复制
    ndarray.copy()函数创建一个深层副本    两个数组不共享任何存储空间
    
25.NumPy-矩阵  
    NumPy包含一个Matrix库numpy.matlib 此模块的函数返回矩阵而不是返回ndarray对象
    matlib.empty(shape,dtype,order)   返回一个新的矩阵，而不初始化元素。该函数接受一下参数 
                    shape为整数元素后整数
    numpy.matlib.zeros()   xp:np.matlib.zeros((2,2))
    numpy.matlib.ones()
    numpy.matlib.eye(n,M,k,dtype)  返回一个对小贤元素为1，其他位置为零   np.matlib.eye(n=3,M=4,k=0,dtype = float)
                n 返回矩阵的行数    M 返回矩阵的列数，默认为n  k    对角线的索引
    numpy.matlib.identity()        函数返回给定大小的单位矩阵。单位举证是主对角线元素都为1的方阵
    numpy.matlib.rand()      函数返回给定大小的填充随机值得矩阵   矩阵总是二维的。而ndarray是一个n维数组。两个对象是可以相互转换的
        k = np.asmatrix (j)  
        
26.NumPy-线性代数
    NumPy包含numpy.linalg模块，提供线性代数所需要的所有功能。
    numpy.dot()  两个数组的点积  
            对于二维向量，其等效矩阵乘法。对于一维数组，他是向量的内积。对于 对于 N 维数组，它是a的最后一个轴上的和与b的倒数第二个轴的乘积。
            矩阵的乘法： 第一个数组的第一行对应

    numy.vdot() 两个向量的点积
        此函数返回两个向量的点积，如果第一个参数是复数，那么他的共轭复数会用于计算，如果参数id是多维数组则会被展开
        展开对应元素相乘再相加
    numpy.inner()  两个数组的内积    matmul 两个数组的矩阵积
    
    待续。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
27.NumPy-Matplotlib  他可与Numpy一起使用。提供了一种有效的matlab开源替代方案，也可以和图形工具包一起使用，PyQt,wxpython
    from matplotlib import pyplot as plt
    
    subplot()subplot()函数允许你在同一图中绘制不同的东西。 在下面的脚本中，绘制正弦和余弦值。
    bar()    pyplot子模块提供bar()函数来生成条形图。 以下示例生成两组x和y数组的条形图。
    
from matplotlib import pyplot as plt
x = [5,8,10]
y = [12,16,6]
x2 = [6,9,11]
y2= [6,15,7]
plt.bar(x,y,align = 'center')
plt.bar(x2,y2,color='g',align='center')
plt.title('Bar graph')
plt.ylabel(' Y axis')
plt.xlabel('x axis')
plt.show()

28.NumPy-使用Matplotlib绘制直方图
    NumPy有一个numpy.histogram()函数，它是数据的频率分布的图形表示。
    水平尺寸相等的矩形对应于类间隔，称为bin,变量height对应于频率
    
    numpy.histogram(a,bin)
        a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) ]
        np.histogram(a,bins =  [0,20,40,60,80,100]) 
        hist,bins = np.histogram(a,bins =  [0,20,40,60,80,100])  
        print hist 
        print bins
        
        
29. NumPy-IO
ndarray对象可以保存到磁盘文件并从磁盘文件加载。可用io功能有：
    load()和save()函数处理numpy二进制文件（带npy扩展名）
    loadtext() 和 savetext()函数处理正常的文本文件
    NumPy 为ndarray对象引入了一个简单的文件格式。 这个npy文件在磁盘文件中，存储重建ndarray所需的数据、图形、dtype和其他信息，以便正确获取数组，即使该文件在具有不同架构的另一台机器上。
    
    np.save('outfile',a)
    np.load('outfile.npy')
    np.savetext('out.txt',a)
    np.loadtxt('out.txt')
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
NumPy-广播
NumPy数组上的迭代   nditer类构造器拥有flags参数 
16.
翻转数组
维度修改
三维数组的numpy.hsplit()
去重元素数组
numpy.average()

numpy.lexsort()

NumPy-线性代数