1.nump的where
第一种用法

np.where(conditions,x,y)
if （condituons成立）：
　　数组变x
else:
　　数组变y

eg:满足结果中key为‘a’的值中字符串含有window的则输出windows,否则输出为Not Windows

operating_system=np.where(cfram['a'].str.contains('Windows'),'Windows','Not Windows')

输出结果为：[‘Windows’ ‘Not Windows’ ‘Windows’ ‘Not Windows’ ‘Windows’]

第二种用法：用if..elif..else处理太丑，用where很简便
eg:

cond2 = np.array([True,False,True,False])
cond1 = np.array([True,True,False,False])
result = []
for i in range(4):
    if (cond1[i] & cond2[i]):   result.append(0);
    elif (cond1[i]):    result.append(1);
    elif (cond2[i]):    result.append(2);
    else :  result.append(3);
print(result)

用where只要一句话

result = np.where(cond1 & cond2,0,np.where(cond1,1,np.where(cond2,2,3)))

输出结果：[0, 1, 2, 3]

2.numpy.loadtext
作用是把文本文件（*.txt）读入并以矩阵或向量的形式输出。它有几个参数：skiprows，delimiter，usecoles和unpack。skiprows作用是跳过头行。在默认情况下是通过空格来分割列的，如果想通过其他来分割列则需要通过delimiter来设置。如果你想跳过几列来读取则需要用usecoles来设置。
正常情况下该返回的是二维矩阵，若设置了unpack=True将返回各列。

 np.loadtxt('loadtxt.txt', skiprows=1,delimiter=',') 

返回结果

array([[ 1.,  2.,  3.,  4.],                                                                               array([[ 4.,  7.,  5.,  9.],                                                                   
       [ 4.,  7.,  5.,  9.],                                                                                              [ 7.,  2.,  2.,  2.]])
       [ 7.,  2.,  2.,  3.]])

from io import StringIO # StringIO behaves like a file object
c=StringIO(u"0 1\n2 3")
print np.loadtxt(c)

结果：

[[ 0.  1.]
 [ 2.  3.]]

3.numpy.reshape

#创建一个数组
a=np.array([1,2,3,4,5,6,7,8])
print a
#输出结果是：[1 2 3 4 5 6 7 8]

使用reshape()方法来更改数组的形状，可以看到看数组d成为了一个二维数组

d=a.reshape((2,4))
print d
#输出结果如下：
[[1 2 3 4]
 [5 6 7 8]]

通过reshape生成的新数组和原始数组公用一个内存，也就是说，假如更改一个数组的元素，另一个数组也将发生改变

a[1]=100
print a
print d
#输出结果如下：
[  1 100   3   4   5   6   7   8]
[[  1 100   3   4]
 [  5   6   7   8]]

同理还可以得到一个三维数组

c=a.reshape((2,2,2))
print c
#输出结果：
[[[  1 100]
  [  3   4]]

 [[  5   6]
  [  7   8]]]

形状变化的原则是数组元素不能发生改变，比如这样写就是错误的，因为数组元素发生了变化

c=a.reshape((2,2,3))
print c
#报错，因为总共8个元素，分成3个2行2列的元素，则要2*2*3=12个元素才可以

reshape((-1,1))相当于一行的数组转置

b=np.arange(0,60,10).reshape((-1,1))
#结果如下：
[[ 0]
 [10]
 [20]
 [30]
 [40]
 [50]]
#故下面是相当于[0,1,2,3,4,5]+上面单列的转置矩阵
a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
#得到结果如下：
[[ 0  1  2  3  4  5]
 [10 11 12 13 14 15]
 [20 21 22 23 24 25]
 [30 31 32 33 34 35]
 [40 41 42 43 44 45]
 [50 51 52 53 54 55]]

4.数组的元素类型可以通过dtype属性获得

# 通过array函数传递list对象
    L = [1, 2, 3, 4, 5, 6]
    print("L = ", L)
    a = np.array(L)
    print("a = ", a)
输出结果('a = ', array([1, 2, 3, 4, 5, 6]))
print(a.dtype)
输出结果：int64

可以通过dtype参数在创建时指定元素类型

d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)     
f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex)  #指定元素类型为复数

5.如果更改元素类型，可以使用astype安全的转换

d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)
f = d.astype(np.int)
print(f)
#结果：
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
#若用下面的直接转，不会报错，但出现一堆乱七八糟的数字
#但不要强制仅修改元素类型，如下面这句，将会以int来解释单精度float类型
d.dtype = np.int
print(d) 

6.numpy.arange
arange函数类似于python的range函数：指定起始值、终止值和步长来创建数组.和Python的range类似，arange同样不包括终值；但arange可以生成浮点类型，而range只能是整数类型.

 np.set_printoptions(linewidth=100, suppress=True) #输出打印的格式
    a = np.arange(1, 10, 0.5)
    print(a)

7.numpy.linespace
通过指定起始值、终止值和元素个数来创建数组，缺省包括终止值

b = np.linspace(1, 10, 10)
print('b = ', b)
#结果
('b = ', array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.]))
# 可以通过endpoint关键字指定是否包括终值
c = np.linspace(1, 10, 10, endpoint=False)
print('c = ', c)
#结果：
('c = ', array([ 1. ,  1.9,  2.8,  3.7,  4.6,  5.5,  6.4,  7.3,  8.2,  9.1]))

8.numpy.logspace可以创建等比数列

# 下面函数创建起始值为10^1，终止值为10^2，有10个数的等比数列 
d = np.logspace(1, 4, 4, endpoint=True, base=2)
print(d)
# 下面创建起始值为2^0，终止值为2^10(包括)，有10个数的等比数列         
f = np.logspace(0, 10, 11, endpoint=True, base=2)     
print(f)                                              

9.使用 frombuffer, fromstring, fromfile等函数可以从字节序列创建数组

s = 'abcdzzzz'
g = np.fromstring(s, dtype=np.int8) #以Ascii码转换
print(g)
#结果：字母对应的Ascii码值
[ 97  98  99 100 122 122 122 122]

10.存取数据
切片存取和python一样

a = np.arange(10)                                                  
print(a)                                                           
# 获取某个元素                                                         
print(a[3])                                                        
# 切片[3,6)，左闭右开                                               
print(a[3:6])                                                      
# 省略开始下标，表示从0开始                                                  
print(a[:5])                                                       
# 下标为负表示从后向前数                                                    
print(a[3:])                                                       
# 步长为2                                                             
print(a[1:9:2])                                                    
# 步长为-1，即翻转                                                
print(a[::-1])                                                     
# 切片数据是原数组的一个视图，与原数组共享内容空间，可以直接修改元素值                               
a[1:4] = 10, 20, 30                                              
print(a)                                                         
# 因此，在实践中，切实注意原始数据是否被破坏，如：                                         
b = a[2:5]                                                         
b[0] = 200                                                         
print(a)                                                           

11.整数/布尔数组存取
11.1根据整数数组存取：当使用整数序列对数组元素进行存取时，
将使用整数序列中的每个元素作为下标，整数序列可以是列表(list)或者数组(ndarray)。
使用整数序列作为下标获得的数组不和原始数组共享数据空间。

a = np.logspace(0, 9, 10, base=2)
print(a)
i = np.arange(0, 10, 2)
print(i)
# 利用i取a中的元素
b = a[i]
print(b)
#返回结果
 [   1.    2.    4.    8.   16.   32.   64.  128.  256.  512.]
[0 2 4 6 8]
[   1.    4.   16.   64.  256.]
#b的元素更改，a中元素不受影响
b[2] = 1.6
print(b)
print(a)
#返回结果：
[   1.     4.     1.6   64.   256. ]
[   1.    2.    4.    8.   16.   32.   64.  128.  256.  512.]    

11.2布尔存取
使用布尔数组i作为下标存取数组a中的元素：返回数组a中所有在数组b中对应下标为True的元素。生成10个满足[0,1)中均匀分布的随机数。

a = np.random.rand(10)
print(a)
# 大于0.5的元素索引
print(a > 0.5) #判断a是否>5,若大于5返回True
#返回结果：
[ True False  True  True  True  True  True False False  True]
# 大于0.5的元素
b = a[a > 0.5] #取a[True]的元素，即全是a>0.5的元素
print(b) #b全是取出a数组中>0.5的元素
# 将原数组中大于0.5的元素截取成0.5
a[a > 0.5] = 0.5
print(a)
# b不受影响
print(b)   #b还是前面取出a数组中>0.5的元素

12.二维数组的切片

 # [[ 0  1  2  3  4  5]                                       
 #  [10 11 12 13 14 15]                                       
 #  [20 21 22 23 24 25]                                       
 #  [30 31 32 33 34 35]                                       
 #  [40 41 42 43 44 45]                                       
 #  [50 51 52 53 54 55]]                                      
 a = np.arange(0, 60, 10)    # 行向量                            
 print('a = ', a)                                             
 b = a.reshape((-1, 1))      # 转换成列向量                         
 print(b)                                                     
 c = np.arange(6)                                             
 print(c)                                                     
 # f = b + c   # 行 + 列                                        
 print(f)                                                     
 # # 合并上述代码：                                                  
 a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)     
 print(a)   
# 二维数组的切片
print(a[[0, 1, 2], [2, 3, 4]]) #取第0行2列，1行3列，2行4列数据
#结果
[ 2 13 24]
print(a[4, [2, 3, 4]]) #取第4行2列，4行3列，4行4列数据
#结果
[42 43 44]
print(a[4:, [2, 3, 4]]) #从第4行列始，后面的2，3，4列数据。a总共5行，故取4行2列，4行3列，4行4列，5行2列，5行3列，5行4列
#结果
[[42 43 44]
 [52 53 54]] 
i = np.array([True, False, True, False, False, True])
#取True的值，i是行向量，即取第一行，第3行，最后一行
print(a[i])
#结果
 [[ 0  1  2  3  4  5]
 [20 21 22 23 24 25]
 [50 51 52 53 54 55]]
print(a[i, 3])取a[i]行的第4列数，下标是从0开始的
#结果
[ 3 23 53]                                           

13.numpy与Python数学库的时间比较
numpy比python快多了，因为numpy中ndarray是C++写的。

for j in np.logspace(0, 7, 8):               
    x = np.linspace(0, 10, j)                
    start = time.clock()                     
    y = np.sin(x)                            
    t1 = time.clock() - start                

    x = x.tolist()                           
    start = time.clock()                     
    for i, t in enumerate(x):                
        x[i] = math.sin(t)                   
    t2 = time.clock() - start                
    print(j, ": ", t1, t2, t2/t1)            

14.元素去重unique

a = np.array((1, 2, 3, 4, 5, 5, 7, 3, 2, 2, 8, 8))
print('original array：', a)
# 使用库函数unique
b = np.unique(a)
print(u'去重后：', b)
#结果：
array([1, 2, 3, 4, 5, 7, 8]）

二维数组的去重，结果会是预期的么？

c = np.array(((1, 2), (3, 4), (5, 6), (1, 3), (3, 4), (7, 6)))
print('二维数组：\n', c)
print('去重后：', np.unique(c))
#结果
array([[1, 2],
       [3, 4],
       [5, 6],
       [1, 3],
       [3, 4],
       [7, 6]])
#去重后并非我们预期的去掉[3,4]：array([1, 2, 3, 4, 5, 6, 7]) 

解决办法：方案1：转换为虚数

    print len(np.split(c, (1, ), axis=1))  #按1，分割，纵向分割，len查看返回几个值，前面好赋值
    r, i = np.split(c, (1, ), axis=1)
    print r  #1，3，5，1，3，7第一列的纵向量
    print i  #第二列的纵向量
    x = r + i * 1j #第一列+第二列.j 将其转换成复数，但是是纵向量
    print x
    x = c[:, 0] + c[:, 1] * 1j #复数行向量
    print('转换成虚数：', x)
    print('虚数去重后：', np.unique(x))  #复数可用Unique去重
    print(np.unique(x, return_index=True))   #return_index是Ture表示同时返回原始数组中的下标
#Return_inverse: True表示返冋重建原始数组用的下标数组
    idx = np.unique(x, return_index=True)[1]  #【1】是取未重复数组下标
    print idx
    print('二维数组去重：\n', c[idx]) #取c数组中idx下标的元素，即该下标已经计算出去重后的下标
    #结果
    array([[1, 2],
       [1, 3],
       [3, 4],
       [5, 6],
       [7, 6]])

解决办法：方案2：利用set
set是一个无序且不重复的元素集合。集合对象是一组无序排列的可哈希的值，集合成员可以做字典中的键。可变数组都是不可以做哈希，故要将array/list转成tuple不可变长，再设置成set集合

print('去重方案2：\n', np.array(list(set([tuple(t) for t in c]))))
#结果：
array([[1, 2],
       [1, 3],
       [3, 4],
       [5, 6],
       [7, 6]])

15.stack and axis 堆叠

a = np.arange(1, 7).reshape((2, 3))
    b = np.arange(11, 17).reshape((2, 3))
    c = np.arange(21, 27).reshape((2, 3))
    d = np.arange(31, 37).reshape((2, 3))
    print('a = \n', a)
    print('b = \n', b)
    print('c = \n', c)
    print('d = \n', d)
    s = np.stack((a, b, c, d), axis=0)
    print('axis = 0 ', s.shape, '\n', s)
    s = np.stack((a, b, c, d), axis=1)
    print('axis = 1 ', s.shape, '\n', s)
    s = np.stack((a, b, c, d), axis=2)
    print('axis = 2 ', s.shape, '\n', s)
    #结果：
    解：axis=0,还是原来的矩阵，shape为(4, 2, 3)4个2行3列矩阵。axis=1,(2, 4, 3)第0列和第一列换,即2个4行3列矩阵。取各种的第一行元素叠加。axis=2,(2, 3, 4)取axis=1时的值再第2列和第3列互换，即2个3行4列矩阵。从axis=0中取每个块中的列的第一个数。axis=-1也为(2, 3, 4)和axis=2取的元素一样
    ('axis = 0 ', (4, 2, 3), '\n', array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[11, 12, 13],
        [14, 15, 16]],

       [[21, 22, 23],
        [24, 25, 26]],

       [[31, 32, 33],
        [34, 35, 36]]]))
('axis = 1 ', (2, 4, 3), '\n', array([[[ 1,  2,  3],
        [11, 12, 13],
        [21, 22, 23],
        [31, 32, 33]],

       [[ 4,  5,  6],
        [14, 15, 16],
        [24, 25, 26],
        [34, 35, 36]]]))
('axis = 2 ', (2, 3, 4), '\n', array([[[ 1, 11, 21, 31],
        [ 2, 12, 22, 32],
        [ 3, 13, 23, 33]],

       [[ 4, 14, 24, 34],
        [ 5, 15, 25, 35],
        [ 6, 16, 26, 36]]]))

15.np.dot 点击
np.dot([1,2,3],[4,5,6]) = 1*4 + 2*5 + 3*6 = 32

16.数组拼接
numpy.concatenate((a1,a2,…), axis=0)
注：a.T表示a的转置

>>> a=np.array([1,2,3])
>>> b=np.array([11,22,33])
>>> c=np.array([44,55,66])
>>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写
array([ 1,  2,  3, 11, 22, 33, 44, 55, 66]) #对于一维数组拼接，axis的值不影响最后的结果

>>> a=np.array([[1,2,3],[4,5,6]])
>>> b=np.array([[11,21,31],[7,8,9]])
>>> np.concatenate((a,b),axis=0)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [11, 21, 31],
       [ 7,  8,  9]])
>>> np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
array([[ 1,  2,  3, 11, 21, 31],
       [ 4,  5,  6,  7,  8,  9]])

15.numpy的基础用法汇总

#coding=utf-8
__author__ = 'mac'

import numpy as np

#python中list中可以有字符，数字等类型。故每次都要判断list的类型，并且转换，所以会慢。而ndarray中只能同一种数据类型
lst=[[1,3,6],[2,4,6]]
print type(lst)
np_lst=np.array(lst)
print (type(np_lst))
np_lst=np.array(lst,dtype=np.float) #dtype可以指定数据类型
print (np_lst.shape) #shape型状，(2,3)2行3列
print  (np_lst.ndim)  #ndim维数
print (np_lst.dtype) #dtype数居类型
print (np_lst.itemsize) #itemsize每个元素的大小，float64,那每个元素是8个字节，故为8
print (np_lst.size) #size的大小，该数组中总共有6个数，则size大小为6

#numpy的some Arrays一些数组
print (np.zeros([2,4])) #生成2行4列的0矩阵
print (np.ones([3,5])) #生成3行5列的都是1的矩阵
print ('Rand:') #随机数：生成均匀分布的数据
print (np.random.rand(2,4)) #生成2行4列的随机数，里面的数据都是均匀分布的
print (np.random.rand()) #不加任何参数只打印了一个随机数
print ('RandInt:') #随机整数
print (np.random.randint(1,10,3)) #因为是生成随机整数，故参数不能为空。生成1-10，不包括10的3个整数
print (np.random.randint(1,10)) #只生成一个随机整数，从1-10，不包括10
print ('Randn:') #随机数：标准正态分布
print (np.random.randn(2,4)) #生成2行4列的标准正态分布的随机数
print ('Choice:') #生成指定的随机数，值只能从给出的随机数中选择
print (np.random.choice([10,20,30])) #生成的随机数只能是10，20，30中选择
print ('Distribute:') #生成一些数学常用的分布：二项分布等
print (np.random.beta(1,10,100)) #从1-10生成100个beta分布的数据

#3 Array opes 数组的操作
print (np.arange(1,11)) #生成1-10的等差数列
print (np.arange(1,11).reshape(2,5)) #reshape生成2行5列的1-10的数组
print (np.arange(1,11).reshape(2,-1)) #-1表示的缺省值，结果是和上面一样生成2行5列的数组
#python中的lst只能追加，不能对里面的元素进行相加等操作，但ndarray是可以对里面的元素进行操作的
print (np.exp(lst)) #exp指数操作,此处np是已经把lst转化为ndarray了，故可以做指数操作
print (np.exp2(lst))
print (np.sqrt(lst))  #开方
print (np.sin(lst))  #sin
print (np.log(lst))  #对数

#axis=0,1,2的解释.axis是和数组的维数有关，最大是到维数-1。
#注：axis越大则深入就越大，axis=0取最外层的数组
#下面是3个2维4列的数组
lst=np.array([[[1,2,3,4],
               [4,5,6,7]],
              [[7,8,9,10],
               [10,11,12,13]],
              [[14,15,16,17],
               [18,19,20,21]]
              ])
#axis=0是取最外层的数组：若是求sum就是下面3个数组相加
            # [[1,2,3,4],
            #    [4,5,6,7]]+
            # [[7,8,9,10],
            #    [10,11,12,13]]+
            # [[14,15,16,17],
            #    [18,19,20,21]]
            # sum求和1+7+14=22 2+8+15=25 3+9+16=28....
print (lst.sum(axis=0))
#结果如下：
# [[22 25 28 31]
#  [32 35 38 41]]
#axis=1是取次外层的数组：2维的求和操作
            # [1,2,3,4], +
            #    [4,5,6,7] 求和：1+4 2+5，3+6，4+7
            # [7,8,9,10], +
            #    [10,11,12,13]  求和：7+10，8+11，9+12，10+13
            # [14,15,16,17], +
            #    [18,19,20,21] 求和：14+18 15+19 16+20 17+21
print (lst.sum(axis=1))
#结果如下：
# [[ 5  7  9 11]
#  [17 19 21 23]
#  [32 34 36 38]]
#axis=2时再取第二内层的数组：
               # [1,2,3,4]  求和:1+2+3+4=10
               # [4,5,6,7]  求和：4+5+6+7=22
               # [7,8,9,10] 求和：7+8+9+10= 34
               # [10,11,12,13]  求和：10+11+12+13 =46
               # [14,15,16,17]  求和：14+15+16+17 =62
               # [18,19,20,21]  求和：18+19+20+21 =78
print (lst.sum(axis=2))
#结果如下：
# [[10 22]
#  [34 46]
#  [62 78]]
print ('Max:')
print (lst.max(axis=1))
#结果如下：
# Max:
# [[ 4  5  6  7]
#  [10 11 12 13]
#  [18 19 20 21]]
print ('Min:')
print (lst.min(axis=2))
#结果如下：
# Min:
# [[ 1  4]
#  [ 7 10]
#  [14 18]]
lst1=np.array([10,20,30,40])
lst2=np.array([4,3,2,1])
#对两个数组相加
print ('Add:')  #两个数组里的元素相加
print (lst1+lst2)
print ('Sub:')     #两个数组元素相减
print (lst1-lst2)
print ('Mul:')   #两个数组元素相乘
print (lst1*lst2)
print ('Div:') #两个数组元素相除
print (lst1/lst2)
print ('Square:') #取平方
print (lst1**2)
print ('Dot:') #点乘
print (np.dot(lst1.reshape([2,2]),lst2.reshape([2,2])))
# [10,20]    [4,3]    [4*10+20*2,10*3+20]
# [30,40] *  [2,1]  =  [30*4+2*40,30*3+40]
#点乘结果如下：
# Dot:
# [[ 80  50]
#  [200 130]]
print ('Cancatenate:') #像python中的追加，即合在一个数组中
print (np.concatenate((lst1,lst2),axis=0)) #将lst2追到lst1后面，生成一维的数组
#结果如下：
# Cancatenate:
# [10 20 30 40  4  3  2  1]
print (np.vstack((lst1,lst2))) #vstack一整行数组追加。原来两个一行的现在换成两行
#结果如下：
# [[10 20 30 40]
#  [ 4  3  2  1]]
print (np.hstack((lst1,lst2))) #原来两个一行的现在换成一个数组，和concatenate一样和append的效果一样
#结果如下：
#[10 20 30 40  4  3  2  1]
print (np.split(lst1,2)) #split拆分将lst1分成2个数组
# 结果如下：
# [array([10, 20]), array([30, 40])]
print (np.copy(lst1)) #copy拷贝数组lst1

16.线性代数在numpy中的应用

import numpy as np
from numpy import random
import matplotlib.pyplot as plt
from numpy.linalg import inv,qr

x=np.array([[1.,2.,3.],[4.,5.,6.]])

y=np.array([[6.,23.],[-1,7],[8,9]])
print x,y
print x.dot(y)
print np.dot(x,np.ones(3))

x=random.randn(5,5)
mat=x.T.dot(x)
print inv(mat)
print mat.dot(inv(mat))
q,r=qr(mat)
print r

常用Numpy.linalg函数（线性代数中用到的方法）

diag        以一维数组的形式返回方阵的对角线(或非对角线)元素，或将一维数组转换为方阵(非对角线元素为0)
dot         矩阵乘法
trace       计算对角线元素的和
det         计算矩阵行列式
eig         计算方阵的本征值和本征向量
inv         计算方阵的逆
pinv        计算矩阵的Moore-Penrose伪逆
qr          计算QR分解
svd         计算奇异值分解(SVD)
solve       解线性方程组Ax=b,其中A为一个方阵
lstsq       计算Ax=b的最小二乘解

17.numpy中的cumsum函数的用法
cumsum数组内的所有元素累加
cumsum参数有：dtype,axis

a = np.array([[1,2,3], [4,5,6]])
print np.cumsum(a)
#输出的结果：
# array([ 1,  3,  6, 10, 15, 21]) 它是上面的元素累加前一个值的结果
print np.cumsum(a, dtype=float)
#输出的结果：
# [  1.   3.   6.  10.  15.  21.]
print np.cumsum(a,axis=0) #每一列累加前一个值(1+4,2+5,3+6)
#输出结果：
# [[1 2 3]
#  [5 7 9]]
print np.cumsum(a,axis=1) #每一行累加前一个值[1,1+2,1+2+3],[4,4+5,4+5+6]
#输出结果：
# [[ 1  3  6]
#  [ 4  9 15]]