numpy的函数用法

1.nump的where
第一种用法

np.where(conditions,x,y)if （condituons成立）：　　数组变xelse:　　数组变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 objectc=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]=100print aprint 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.intprint(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.6print(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.5a[a > 0.5] = 0.5print(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)# 使用库函数uniqueb = 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个字节，故为8print (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，不包括10print ('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))  #sinprint (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+21print (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 =78print (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