Numpy笔记

# -*- coding: utf-8 -*-
import numpy as np

数组文件读写

In [11]:
arr = np.arange(10)
np.save('some_array', arr)
In [12]:
print np.load('some_array.npy')
[0 1 2 3 4 5 6 7 8 9]
In [13]:
#多个数组压缩存储
np.savez('arrays.npz', a=arr, b=arr)
arch = np.load('arrays.npz')
print arch['b']
[0 1 2 3 4 5 6 7 8 9]

TXT文件读取

In [15]:
arr = np.loadtxt('array_ex.txt', delimiter = ',')
arr
Out[15]:
array([[ 0.580052,  0.18673 ,  1.040717,  1.134411],
       [ 0.194163, -0.636917, -0.938659,  0.124094],
       [-0.12641 ,  0.268607, -0.695724,  0.047428],
       [-1.484413,  0.004176, -0.744203,  0.005487],
       [ 2.302869,  0.200131,  1.670238, -1.88109 ],
       [-0.19323 ,  1.047233,  0.482803,  0.960334]])
In [16]:
import matplotlib.pyplot as plt
import pylab
In [20]:
# intro
points = np.arange(-5, 5, 0.01)     #生成100个点
xs, ys = np.meshgrid(points, points)            #xs, ys互为转置矩阵
print xs
print ys
z = np.sqrt(xs ** 2 + ys ** 2)
z
[[-5.   -4.99 -4.98 ...,  4.97  4.98  4.99]
 [-5.   -4.99 -4.98 ...,  4.97  4.98  4.99]
 [-5.   -4.99 -4.98 ...,  4.97  4.98  4.99]
 ..., 
 [-5.   -4.99 -4.98 ...,  4.97  4.98  4.99]
 [-5.   -4.99 -4.98 ...,  4.97  4.98  4.99]
 [-5.   -4.99 -4.98 ...,  4.97  4.98  4.99]]
[[-5.   -5.   -5.   ..., -5.   -5.   -5.  ]
 [-4.99 -4.99 -4.99 ..., -4.99 -4.99 -4.99]
 [-4.98 -4.98 -4.98 ..., -4.98 -4.98 -4.98]
 ..., 
 [ 4.97  4.97  4.97 ...,  4.97  4.97  4.97]
 [ 4.98  4.98  4.98 ...,  4.98  4.98  4.98]
 [ 4.99  4.99  4.99 ...,  4.99  4.99  4.99]]
Out[20]:
array([[ 7.07106781,  7.06400028,  7.05693985, ...,  7.04988652,
         7.05693985,  7.06400028],
       [ 7.06400028,  7.05692568,  7.04985815, ...,  7.04279774,
         7.04985815,  7.05692568],
       [ 7.05693985,  7.04985815,  7.04278354, ...,  7.03571603,
         7.04278354,  7.04985815],
       ..., 
       [ 7.04988652,  7.04279774,  7.03571603, ...,  7.0286414 ,
         7.03571603,  7.04279774],
       [ 7.05693985,  7.04985815,  7.04278354, ...,  7.03571603,
         7.04278354,  7.04985815],
       [ 7.06400028,  7.05692568,  7.04985815, ...,  7.04279774,
         7.04985815,  7.05692568]])
In [23]:
plt.imshow(z, cmap = plt.cm.gray);
plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")
pylab.show()

mathematical_and_statistical_methods

In [24]:
arr = np.random.randn(5, 4)
print arr
print arr.mean()
print arr.sum()
print arr.mean(axis = 1)           #对每一行的元素求和
print arr.sum(0)         #对每一列的元素求和,axis可以省略
[[ 1.09207092 -1.49942985 -0.1858201   0.57987917]
 [ 0.14695683  0.47383032  1.561152    1.27616339]
 [ 0.60407416  0.1249682  -1.45560993  0.86407568]
 [-1.68302967  0.91679486 -0.93981695  0.3895989 ]
 [-1.18526704  2.0848987   0.30565185  1.40602387]]
0.243858266101
4.87716532203
[-0.00332496  0.86452563  0.03437703 -0.32911321  0.65282685]
[-1.0251948   2.10106224 -0.71444314  4.51574103]

'''

cumsum:

  • 按列操作:a[i][j] += a[i - 1][j]
  • 按行操作:a[i][j] += a[i][j - 1]

cumprod:

  • 按列操作:a[i][j] *= a[i - 1][j]
  • 按行操作:a[i][j] *= a[i][j - 1]

'''

In [25]:
arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
print arr.cumsum(0)
print arr.cumprod(1)
[[ 0  1  2]
 [ 3  5  7]
 [ 9 12 15]]
[[  0   0   0]
 [  3  12  60]
 [  6  42 336]]

methods_for_boolean_arrays

In [27]:
arr = np.random.randn(100)
(arr > 0).sum()
Out[27]:
49
In [30]:
#对数组逻辑操作
bools = np.array([False, False, True, False])
print bools.any() # 有一个为True则返回True
print bools.all() # 有一个为False则返回False
True
False

expressing_conditional_logic_as_array_operations

In [32]:
'''
关于zip函数的一点解释,zip可以接受任意多参数,然后重新组合成1个tuple列表。
zip([1, 2, 3], [4, 5, 6], [7, 8, 9])
返回结果:[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
'''
print '通过真值表选择元素'
x_arr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
y_arr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
result = [(x if c else y) for x, y, c in zip(x_arr, y_arr, cond)] # 通过列表推到实现
result
通过真值表选择元素
Out[32]:
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]
In [34]:
np.where(cond, x_arr, y_arr)   #使用Numpy的where函数
Out[34]:
array([ 1.1,  2.2,  1.3,  1.4,  2.5])
In [35]:
#更多where的例子
arr = np.random.randn(4, 4)
print arr
print np.where(arr > 0, 2, -2)
print np.where(arr < 0, 2, arr)
[[-1.61187604 -0.71774121  3.1109884  -0.49302981]
 [-0.63756198 -0.82501352  0.47298513 -2.11598202]
 [ 1.4840521   0.82438256  0.14449561  1.27314362]
 [ 0.41043674 -0.12611436  0.95429373  0.49979788]]
[[-2 -2  2 -2]
 [-2 -2  2 -2]
 [ 2  2  2  2]
 [ 2 -2  2  2]]
[[ 2.          2.          3.1109884   2.        ]
 [ 2.          2.          0.47298513  2.        ]
 [ 1.4840521   0.82438256  0.14449561  1.27314362]
 [ 0.41043674  2.          0.95429373  0.49979788]]
In [36]:
cond_1 = np.array([True, False, True, True, False])
cond_2 = np.array([False, True, False, True, False])
# 传统代码如下
result = []
for i in xrange(len(cond)):
    if cond_1[i] and cond_2[i]:
        result.append(0)
    elif cond_1[i]:
        result.append(1)
    elif cond_2[i]:
        result.append(2)
    else:
        result.append(3)
result
Out[36]:
[1, 2, 1, 0, 3]
In [37]:
#np版本代码
result = np.where(cond_1 & cond_2, 0, 
                 np.where(cond_1, 1, np.where(cond_2, 2, 3)))
result
Out[37]:
array([1, 2, 1, 0, 3])

排序

In [41]:
arr = np.random.randn(5, 3)
arr.sort(1)        #对每一行元素做排序
arr
Out[41]:
array([[-1.62353055, -0.57238878,  2.69797785],
       [ 0.34879682,  0.6650742 ,  0.67582493],
       [-2.41802124, -0.47495947,  0.2498362 ],
       [-0.58148306,  0.46902651,  1.20460726],
       [-0.88678096,  0.14011221,  1.17825707]])
In [42]:
#找位置在5%de zishu arr = np.random.randn(1000)
arr.sort()
arr[int(0.05 * len(arr))]
Out[42]:
-1.650110367339956

unique去重

In [43]:
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
print sorted(set(names))     #传统Python做法
print np.unique(names)
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
print np.unique(ints)
['Bob', 'Joe', 'Will']
['Bob' 'Joe' 'Will']
[1 2 3 4]
In [44]:
#查找数组元素是否在另一数组
values = np.array([6, 0, 0, 3, 2, 5, 6])
np.in1d(values, [2, 3, 6])
Out[44]:
array([ True, False, False,  True,  True, False,  True], dtype=bool)

数组的索引和切片

In [45]:
# 通过索引访问二维数组某一行或某个元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print arr[2]
print arr[0][2]
print arr[0, 2] # 普通Python数组不能用。
[7 8 9]
3
3
In [48]:
# 对更高维数组的访问和操作
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print arr[0]  # 结果是个2维数组
print arr[1, 0] # 结果是个2维数组
old_values = arr[0].copy()  # 复制arr[0]的值
arr[0] = 42 # 把arr[0]所有的元素都设置为同一个值
print arr
arr[0] = old_values # 把原来的数组写回去
print arr
print
[[1 2 3]
 [4 5 6]]
[7 8 9]
[[[42 42 42]
  [42 42 42]]

 [[ 7  8  9]
  [10 11 12]]]
[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]

In [49]:
print '使用切片访问和操作数组'
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print arr[1:6]  # 打印元素arr[1]到arr[5]
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print arr[:2] # 打印第1、2行
print arr[:2, 1:] # 打印第1、2行,第2、3列
print arr[:, :1]  # 打印第一列的所有元素
arr[:2, 1:] = 0 # 第1、2行,第2、3列的元素设置为0
arr
使用切片访问和操作数组
[2 3 4 5 6]
[[1 2 3]
 [4 5 6]]
[[2 3]
 [5 6]]
[[1]
 [4]
 [7]]
Out[49]:
array([[1, 0, 0],
       [4, 0, 0],
       [7, 8, 9]])
In [61]:
print '使用布尔数组作为索引'
name_arr = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
rnd_arr = np.random.randn(7, 4) # 随机7*4数组
print rnd_arr
print name_arr == 'Bob' # 返回布尔数组,元素等于'Bob'为True,否则False。
print rnd_arr[name_arr == 'Bob']  # 利用布尔数组选择行
print rnd_arr[name_arr == 'Bob', :2]  # 增加限制打印列的范围
print rnd_arr[-(name_arr == 'Bob')] # 对布尔数组的内容取反
mask_arr = (name_arr == 'Bob') | (name_arr == 'Will') # 逻辑运算混合结果
print rnd_arr[mask_arr]
rnd_arr[name_arr != 'Joe'] = 7  # 先布尔数组选择行,然后把每行的元素设置为7。
print rnd_arr
使用布尔数组作为索引
[[-0.50064013  0.09851408 -0.40607405  0.41253234]
 [ 0.03398787 -0.642079    1.08436755  0.34424229]
 [ 0.40445128 -1.01153536 -1.68464088 -1.35077324]
 [-1.0737359   0.66996989  1.54764896 -1.35938803]
 [-0.33381751  0.86107253 -0.41336677 -0.3794855 ]
 [-0.36080737  1.09020169  0.48040975 -1.67843699]
 [ 0.57294986  3.07872855 -0.12478604  2.37751023]]
[ True False False  True False False False]
[[-0.50064013  0.09851408 -0.40607405  0.41253234]
 [-1.0737359   0.66996989  1.54764896 -1.35938803]]
[[-0.50064013  0.09851408]
 [-1.0737359   0.66996989]]
[[ 0.03398787 -0.642079    1.08436755  0.34424229]
 [ 0.40445128 -1.01153536 -1.68464088 -1.35077324]
 [-0.33381751  0.86107253 -0.41336677 -0.3794855 ]
 [-0.36080737  1.09020169  0.48040975 -1.67843699]
 [ 0.57294986  3.07872855 -0.12478604  2.37751023]]
[[-0.50064013  0.09851408 -0.40607405  0.41253234]
 [ 0.40445128 -1.01153536 -1.68464088 -1.35077324]
 [-1.0737359   0.66996989  1.54764896 -1.35938803]
 [-0.33381751  0.86107253 -0.41336677 -0.3794855 ]]
[[ 7.          7.          7.          7.        ]
 [ 0.03398787 -0.642079    1.08436755  0.34424229]
 [ 7.          7.          7.          7.        ]
 [ 7.          7.          7.          7.        ]
 [ 7.          7.          7.          7.        ]
 [-0.36080737  1.09020169  0.48040975 -1.67843699]
 [ 0.57294986  3.07872855 -0.12478604  2.37751023]]
C:\ProgramData\Anaconda2\lib\site-packages\ipykernel\__main__.py:8: DeprecationWarning: numpy boolean negative, the `-` operator, is deprecated, use the `~` operator or the logical_not function instead.
In [62]:
#使用普通一维数组生成NumPy一维数组'
data = [4, 3, 4, 6, 9]
arr = np.array(data)
print arr
print arr.dtype
[4 3 4 6 9]
int32
In [63]:
#使用普通二维数组生成NumPy二维数组
data = [[1, 2, 3], [5, 6, 7]]
arr = np.array(data)
print arr
print arr.shape
[[1 2 3]
 [5 6 7]]
(2L, 3L)
In [67]:
#使用zeros/empty
print '使用zeros/empty'
print np.zeros(10) # 生成包含10个0的一维数组
print np.zeros((3, 6)) # 生成3*6的二维数组
print np.empty((2, 3, 2)) # 生成2*3*2的三维数组,所有元素未初始化。
print

print '使用arrange生成连续元素'
print np.arange(15)  # [0, 1, 2, ..., 14]
使用zeros/empty
[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
[[ 0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.]]
[[[ 0.  0.]
  [ 0.  0.]
  [ 0.  0.]]

 [[ 0.  0.]
  [ 0.  0.]
  [ 0.  0.]]]

使用arrange生成连续元素
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

data_types_for_ndarray

In [69]:
print '生成数组时指定数据类型'
arr = np.array([1, 2, 3], dtype = np.float64)
print arr.dtype
arr = np.array([1, 2, 3], dtype = np.int32)
print arr.dtype
生成数组时指定数据类型
float64
int32
In [71]:
print '使用astype复制数组并转换数据类型'
int_arr = np.array([1, 2, 3, 4, 5])
float_arr = int_arr.astype(np.float)
print int_arr.dtype
print float_arr.dtype
使用astype复制数组并转换数据类型
int32
float64
In [72]:
print '使用astype将float转换为int时小数部分被舍弃'
float_arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
int_arr = float_arr.astype(dtype = np.int)
print int_arr
print
使用astype将float转换为int时小数部分被舍弃
[ 3 -1 -2  0 12 10]

In [73]:
print '使用astype把字符串转换为数组,如果失败抛出异常。'
str_arr = np.array(['1.25', '-9.6', '42'], dtype = np.string_)
float_arr = str_arr.astype(dtype = np.float)
print float_arr
print
使用astype把字符串转换为数组,如果失败抛出异常。
[  1.25  -9.6   42.  ]

In [75]:
print 'astype使用其它数组的数据类型作为参数'
int_arr = np.arange(10)
float_arr = np.array([.23, 0.270, .357, 0.44, 0.5], dtype = np.float64)
print int_arr.astype(float_arr.dtype)
print int_arr[0], int_arr[1]  # astype做了复制,数组本身不变。
astype使用其它数组的数据类型作为参数
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]
0 1
In [76]:
print 'Fancy Indexing: 使用整数数组作为索引'
arr = np.empty((8, 4))
for i in range(8):
    arr[i] = i
print arr
print arr[[4, 3, 0, 6]] # 打印arr[4]、arr[3]、arr[0]和arr[6]。
print arr[[-3, -5, -7]] # 打印arr[3]、arr[5]和arr[-7]行
arr = np.arange(32).reshape((8, 4))  # 通过reshape变换成二维数组
print arr[[1, 5, 7, 2], [0, 3, 1, 2]] # 打印arr[1, 0]、arr[5, 3],arr[7, 1]和arr[2, 2]
print arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]  # 1572行的0312列
print arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])] # 可读性更好的写法
Fancy Indexing: 使用整数数组作为索引
[[ 0.  0.  0.  0.]
 [ 1.  1.  1.  1.]
 [ 2.  2.  2.  2.]
 [ 3.  3.  3.  3.]
 [ 4.  4.  4.  4.]
 [ 5.  5.  5.  5.]
 [ 6.  6.  6.  6.]
 [ 7.  7.  7.  7.]]
[[ 4.  4.  4.  4.]
 [ 3.  3.  3.  3.]
 [ 0.  0.  0.  0.]
 [ 6.  6.  6.  6.]]
[[ 5.  5.  5.  5.]
 [ 3.  3.  3.  3.]
 [ 1.  1.  1.  1.]]
[ 4 23 29 10]
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]

operations_between_arrays_and_scalars

In [77]:
# 数组乘法/减法,对应元素相乘/相减。
arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
print arr * arr
print arr - arr
print

# 标量操作作用在数组的每个元素上
arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
print 1 / arr
print arr ** 0.5  # 开根号
[[  1.   4.   9.]
 [ 16.  25.  36.]]
[[ 0.  0.  0.]
 [ 0.  0.  0.]]

[[ 1.          0.5         0.33333333]
 [ 0.25        0.2         0.16666667]]
[[ 1.          1.41421356  1.73205081]
 [ 2.          2.23606798  2.44948974]]

transposing_arrays_and_swapping_axes

In [79]:
print '转置矩阵'
arr = np.arange(15).reshape((3, 5))
print arr
print arr.T
print

print '转置矩阵做点积'
arr = np.random.randn(6, 3)
print np.dot(arr.T, arr)
print

print '高维矩阵转换'
arr = np.arange(16).reshape((2, 2, 4))
print arr
'''
详细解释:
arr数组的内容为
- a[0][0] = [0, 1, 2, 3]
- a[0][1] = [4, 5, 6, 7]
- a[1][0] = [8, 9, 10, 11]
- a[1][1] = [12, 13, 14, 15]
transpose的参数为坐标,正常顺序为(0, 1, 2, ... , n - 1),
现在传入的为(1, 0, 2)代表a[x][y][z] = a[y][x][z],第0个和第1个坐标互换。
- a'[0][0] = a[0][0] = [0, 1, 2, 3]
- a'[0][1] = a[1][0] = [8, 9, 10, 11]
- a'[1][0] = a[0][1] = [4, 5, 6, 7]
- a'[1][1] = a[1][1] = [12, 13, 14, 15]
'''
print arr.transpose((1, 0, 2))
print arr.swapaxes(1, 2)  # 直接交换第1和第2个坐标
转置矩阵
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
[[ 0  5 10]
 [ 1  6 11]
 [ 2  7 12]
 [ 3  8 13]
 [ 4  9 14]]

转置矩阵做点积
[[  9.6780896   -4.09607302   2.43183899]
 [ -4.09607302   7.16605124  -8.12088653]
 [  2.43183899  -8.12088653  11.0147623 ]]

高维矩阵转换
[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]
[[[ 0  1  2  3]
  [ 8  9 10 11]]

 [[ 4  5  6  7]
  [12 13 14 15]]]
[[[ 0  4]
  [ 1  5]
  [ 2  6]
  [ 3  7]]

 [[ 8 12]
  [ 9 13]
  [10 14]
  [11 15]]]

concatenating_and_splitting_arrays

In [80]:
print '连接两个二维数组'
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
print np.concatenate([arr1, arr2], axis = 0)  # 按行连接
print np.concatenate([arr1, arr2], axis = 1)  # 按列连接
print
连接两个二维数组
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

In [81]:
# 所谓堆叠,参考叠盘子。。。连接的另一种表述
print '垂直stack与水平stack'
print np.vstack((arr1, arr2)) # 垂直堆叠
print np.hstack((arr1, arr2)) # 水平堆叠
print
垂直stack与水平stack
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

In [83]:
print '拆分数组'
arr = np.random.randn(5, 5)
print arr
print '水平拆分'
first, second, third = np.split(arr, [1, 3], axis = 0)
print 'first'
print first
print 'second'
print second
print 'third'
print third
print '垂直拆分'
first, second, third = np.split(arr, [1, 3], axis = 1)
print 'first'
print first
print 'second'
print second
print 'third'
print third
print
拆分数组
[[-1.51640891 -0.13371911 -0.36430447 -0.06575367  0.41526838]
 [-0.12715    -0.80040536  0.36802663  0.73072022  2.41031011]
 [ 1.43588793 -1.03191859  1.17664175 -0.39438997  0.87701189]
 [ 0.48202403  0.25310873  0.86505169  0.05730818  0.62836743]
 [ 0.2095295   0.54337884 -0.07741175  0.54473913  0.59034865]]
水平拆分
first
[[-1.51640891 -0.13371911 -0.36430447 -0.06575367  0.41526838]]
second
[[-0.12715    -0.80040536  0.36802663  0.73072022  2.41031011]
 [ 1.43588793 -1.03191859  1.17664175 -0.39438997  0.87701189]]
third
[[ 0.48202403  0.25310873  0.86505169  0.05730818  0.62836743]
 [ 0.2095295   0.54337884 -0.07741175  0.54473913  0.59034865]]
垂直拆分
first
[[-1.51640891]
 [-0.12715   ]
 [ 1.43588793]
 [ 0.48202403]
 [ 0.2095295 ]]
second
[[-0.13371911 -0.36430447]
 [-0.80040536  0.36802663]
 [-1.03191859  1.17664175]
 [ 0.25310873  0.86505169]
 [ 0.54337884 -0.07741175]]
third
[[-0.06575367  0.41526838]
 [ 0.73072022  2.41031011]
 [-0.39438997  0.87701189]
 [ 0.05730818  0.62836743]
 [ 0.54473913  0.59034865]]

In [85]:
# 堆叠辅助类
arr = np.arange(6)
arr1 = arr.reshape((3, 2))
arr2 = np.random.randn(3, 2)
print 'r_用于按行堆叠'
print np.r_[arr1, arr2]
print 'c_用于按列堆叠'
print np.c_[np.r_[arr1, arr2], arr]
print '切片直接转为数组'
print np.c_[1:6, -10:-5]
r_用于按行堆叠
[[ 0.          1.        ]
 [ 2.          3.        ]
 [ 4.          5.        ]
 [ 0.61670658 -0.18470724]
 [ 0.70806972 -0.03176755]
 [ 1.64650603  1.11209963]]
c_用于按列堆叠
[[ 0.          1.          0.        ]
 [ 2.          3.          1.        ]
 [ 4.          5.          2.        ]
 [ 0.61670658 -0.18470724  3.        ]
 [ 0.70806972 -0.03176755  4.        ]
 [ 1.64650603  1.11209963  5.        ]]
切片直接转为数组
[[  1 -10]
 [  2  -9]
 [  3  -8]
 [  4  -7]
 [  5  -6]]

fancy_indexing_equivalents

In [86]:
print 'Fancy Indexing例子代码'
arr = np.arange(10) * 100
inds = [7, 1, 2, 6]
print arr[inds]
print
Fancy Indexing例子代码
[700 100 200 600]

In [88]:
print '使用take'
print arr.take(inds)
print

print '使用put更新内容'
arr.put(inds, 50)
print arr
arr.put(inds, [70, 10, 20, 60])
print arr
print

print 'take,指定轴'
arr = np.random.randn(2, 4)
inds = [2, 0, 2, 1]
print arr
print arr.take(inds, axis = 1)  # 按列take
使用take
[70 10 20 60]

使用put更新内容
[  0  50  50 300 400 500  50  50 800 900]
[  0  10  20 300 400 500  60  70 800 900]

take,指定轴
[[ 0.42373475 -1.44294987  0.76828616 -0.13928908]
 [ 0.1575532  -0.18573901 -2.09807312 -1.23269719]]
[[ 0.76828616  0.42373475  0.76828616 -1.44294987]
 [-2.09807312  0.1575532  -2.09807312 -0.18573901]]
In [90]:
print 'Repeat: 按元素'
arr = np.arange(3)
print arr.repeat(3)
print arr.repeat([2, 3, 4]) # 3个元素,分别复制2, 3, 4次。长度要匹配!
print

print 'Repeat,指定轴'
arr = np.random.randn(2, 2)
print arr
print arr.repeat(2, axis = 0) # 按行repeat
print arr.repeat(2, axis = 1) # 按列repeat
print arr.repeat(2, axis = 0) # 按行repeat
print

print 'Tile: 参考贴瓷砖'
print np.tile(arr, 2)
print np.tile(arr, (2, 3))  # 指定每个轴的tile次数
Repeat: 按元素
[0 0 0 1 1 1 2 2 2]
[0 0 1 1 1 2 2 2 2]

Repeat,指定轴
[[-0.03689278  0.04003134]
 [ 0.81477067  0.14168013]]
[[-0.03689278  0.04003134]
 [-0.03689278  0.04003134]
 [ 0.81477067  0.14168013]
 [ 0.81477067  0.14168013]]
[[-0.03689278 -0.03689278  0.04003134  0.04003134]
 [ 0.81477067  0.81477067  0.14168013  0.14168013]]
[[-0.03689278  0.04003134]
 [-0.03689278  0.04003134]
 [ 0.81477067  0.14168013]
 [ 0.81477067  0.14168013]]

Tile: 参考贴瓷砖
[[-0.03689278  0.04003134 -0.03689278  0.04003134]
 [ 0.81477067  0.14168013  0.81477067  0.14168013]]
[[-0.03689278  0.04003134 -0.03689278  0.04003134 -0.03689278  0.04003134]
 [ 0.81477067  0.14168013  0.81477067  0.14168013  0.81477067  0.14168013]
 [-0.03689278  0.04003134 -0.03689278  0.04003134 -0.03689278  0.04003134]
 [ 0.81477067  0.14168013  0.81477067  0.14168013  0.81477067  0.14168013]]
In [91]:
print "将一维数组转换为二维数组"
arr = np.arange(8)
print arr.reshape((4, 2))
print arr.reshape((4, 2)).reshape((2, 4)) # 支持链式操作
print

print "维度大小自动推导"
arr = np.arange(15)
print arr.reshape((5, -1))
print

print "获取维度信息并应用"
other_arr = np.ones((3, 5))
print other_arr.shape
print arr.reshape(other_arr.shape)
print

print "高维数组拉平"
arr = np.arange(15).reshape((5, 3))
print arr.ravel()
将一维数组转换为二维数组
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
[[0 1 2 3]
 [4 5 6 7]]

维度大小自动推导
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]

获取维度信息并应用
(3L, 5L)
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

高维数组拉平
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
In [ ]:
 
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: numpy是一个高性能的科学计算库,用于处理大型数据集和矩阵运算。它是Python科学计算生态系统中最重要的库之一,提供了丰富的功能和工具。 在numpy的学习过程中,我创建了一个名为"numpy笔记.xmind"的思维导图来总结和记录重要的概念和函数。 首先,我在思维导图中列出了numpy的基本数据结构,包括多维数组(ndarray)、切片和索引。我理解了如何创建和操作这些数据结构,以及如何使用切片和索引访问数组中的元素。 其次,在思维导图中,我详细记录了numpy中的常用函数和方法。这些函数包括数学运算(如加法、乘法和指数运算)、统计函数(如平均值、标准差和方差)和数组操作(如形状变换、拼接和切割)。对于每个函数,我还注明了其参数和用法,以便以后参考。 此外,我还在思维导图中添加了numpy的广播功能和ufunc函数。广播允许我们在不同形状的数组之间进行元素级别的操作,而ufunc函数则可以对数组进行逐元素的函数调用。对于这两个功能,我记录了它们的应用场景和使用方法。 最后,我在思维导图中补充了一些numpy的高级特性和应用,如随机数生成、文件IO以及与其他科学计算库(如pandas和matplotlib)的集成。这些特性和应用使numpy成为了进行数据分析和科学计算的重要工具。 通过创建和总结"numpy笔记.xmind"这个思维导图,我能够更好地理解和掌握numpy的知识。这份笔记将成为我学习和使用numpy的重要参考资料,帮助我在科学计算和数据分析的过程中提高效率和准确性。 ### 回答2: numpy(Numerical Python)是Python中用于进行科学计算的一个库。它提供了丰富的高性能数值计算工具,特别是对于大规模多维数组的操作。下面是关于numpy的一些笔记。 1. 数组的创建:numpy使用ndarray对象来存储多维数组。可以使用numpy.array()函数创建数组,也可以使用numpy.zeros()、numpy.ones()等函数创建特定初始值的数组。 2. 数组的属性:可以使用ndarray的属性来获取数组的形状、大小、数据类型等信息。例如,shape属性可以得到数组的维度大小,dtype属性可以得到数组的数据类型。 3. 数组的索引和切片:可以通过索引来访问数组中的元素。numpy中的索引从0开始,可以使用负数表示相对于数组尾部的位置。切片可以用来获取数组的部分元素。可以使用冒号分隔切片的起始、结束和步长值。 4. 数组的运算:numpy支持对数组的逐元素运算,包括加减乘除、求幂、取余等。可以使用numpy的函数进行常见的数学运算,也可以使用ndarray对象的方法进行相应的操作。 5. 广播:numpy中的广播机制可以自动处理形状不一致的数组之间的运算。广播可以使得形状不一致的数组能够按需扩展以便进行元素运算,而不需要进行明确的形状调整操作。 6. 数组的重塑和转置:可以使用reshape()函数对数组进行重新排列,改变其形状。transpose()函数可以用来进行数组的转置操作。 7. 数组的聚合操作:numpy提供了很多用于数组聚合操作的函数,例如对数组进行求和、求平均、求最大最小值等。 8. 数组的存储和读取:可以使用numpy提供的函数将数组保存到文件中,也可以使用numpy的load()函数从文件中加载数组。 以上是关于numpy的一些基础笔记numpy在科学计算、数据分析等领域具有广泛的应用。掌握numpy的基本操作和常用函数,能够更高效地进行数值计算和数据处理任务。 ### 回答3: numpy是一个开源的Python库,提供了高效的多维数组对象以及对数组操作的函数。笔记.xmind是一种思维导图的文件格式。结合两者,我可以将numpy的使用方法和相关概念通过思维导图的方式记录下来。 在笔记.xmind中,我可以使用中心主题表示numpy,然后通过子主题展开numpy的各个方面。例如,我可以创建一个子主题来介绍numpy的数组对象,包括数组的创建、形状、类型等信息。另外,我还可以创建子主题来记录numpy数组操作的函数,例如数组的索引与切片操作、数组的运算操作等。在每个子主题中,我可以使用节点来记录具体的代码示例,以及相关的说明和注意事项。 除了记录numpy的使用方法外,我还可以创建子主题来介绍numpy中的常用概念和特性。例如,我可以创建一个子主题来介绍numpy中的广播机制,以及在数组运算中的应用。另外,我还可以创建子主题来介绍numpy中的向量化操作和矩阵运算,以及其在科学计算中的重要性。 在整个思维导图中,我可以使用不同的颜色、字体和图标来区分不同的主题或节点,以便更好地组织和呈现信息。可以使用箭头来表示不同主题之间的关系,例如通过箭头表示某个主题是另一个主题的子主题或相关主题。 通过将numpy的使用方法和相关概念以思维导图的形式记录在笔记.xmind中,我可以更清晰地了解和掌握numpy的知识,并且可以随时查阅和复习。这样可以帮助我更好地应用numpy进行数据分析和科学计算,并提高工作效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值