numpy介绍

创建numpy的数组

一维数组是什么样子

可以理解为格子纸的一行就是一个一维数据

  1.  two_arr = np.array([1, 2, 3])

二维数组什么样子

理解为一张格子纸, 多个一维数组构成一个二维数组

  1.  two_arr = np.array([
  2.      [1, 2, 3],
  3.      [4, 5, 6],
  4.      [7, 8, 9]
  5.  ])
  6.  print(two_arr)
  7.  [[1 2 3]  # 三行三列的二维列表
  8.   [4 5 6]
  9.   [7 8 9]]

三维数组什么样子

  1. three_arr = np.array([
  2.     [
  3.         [1, 2, 3],
  4.         [1, 2, 3],
  5.         [1, 2, 3],
  6.         [1, 2, 3],
  7.     ],
  8.     [
  9.         [4, 5, 6],
  10.         [4, 5, 6],
  11.         [4, 5, 6],
  12.         [4, 5, 6],
  13.     ]
  14. ])
  15. print(three_arr)
  16. # [[[1 2 3]
  17. #   [1 2 3]
  18. #   [1 2 3]
  19. #   [1 2 3]]
  20. #
  21. #  [[4 5 6]
  22. #   [4 5 6]
  23. #   [4 5 6]
  24. #   [4 5 6]]]

np.array()

传入一个列表, 返回一个数组

  1. li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. arr = np.array(li)
  3. print(type(arr), arr)
  4. # <class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9]

np.arange(10)

类似于python中的range

  1. arr = np.arange(10)
  2. print(type(arr), arr)
  3. <class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9]
  4. # 和python的range类型, 顾头不顾尾, 支持步长, 和python的range的区别在于, 起始值和步长支持小数
  5. arr = np.arange(1.2, 10.5, 0.5)
  6. print(type(arr), arr)
  7. # <class 'numpy.ndarray'> [ 1.2  1.7  2.2  2.7  3.2  3.7  4.2  4.7  5.2  5.7  6.2  6.7  7.2  7.7 8.2  8.7  9.2  9.7 10.2]

拓展: 将一维数据变成多维数组

前提保证, reshape()中的行和列相乘等于数组中的全部元素的个数

将一维数组转换成二维数组

  1. arr = np.arange(0, 15).reshape(3, 5)
  2. print(arr)
  3. # [[ 0  1  2  3  4]
  4. #  [ 5  6  7  8  9]
  5. #  [10 11 12 13 14]]

将一维数组转换成三维数组

  1. arr = np.arange(30).reshape(3, 2, 5)
  2. print(arr)
  3. # [[[ 0  1  2  3  4]
  4. #   [ 5  6  7  8  9]]
  5. #
  6. #  [[10 11 12 13 14]
  7. #   [15 16 17 18 19]]
  8. #
  9. #  [[20 21 22 23 24]
  10. #   [25 26 27 28 29]]]
  11.  
  12. # 三维数组可以只给出两个数值, 另外一个用-1代替, 自动求剩下一个一个应该是多少
  13. # 比如:arr = np.arange(30).reshape(3, 2, -1)  会自动求出-1位置的数应该是6

np.linspace(0, 10, 5)

把0到10范围的数分成长度为5的数组, 保证每个数之间的差是相等的, 前包后也包

  1. arr = np.linspace(0, 10, 5)
  2. print(type(arr), arr)
  3. # <class 'numpy.ndarray'> [ 0.   2.5  5.   7.5 10. ]

np.zeros(10)

创建全0的数组

  1. arr = np.zeros(10)
  2. print(arr)
  3. # [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  4. # 默认是float类型, 可以指定dtype, 可以指定创建几维的数据传一个元祖, 比如np.zeros(3,2,5), 就是创建一个3页2行5列的全0数组

np.ones(10)

创建全1的数组

  1. arr = np.ones(10)
  2. print(arr)
  3. # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
  4. # 默认使用float类型, 可以指定dtype, 可以指定创建几维的数据传一个元祖, 比如np.ones(3,2,5), 就是创建一个3页2行5列的全1数组

np.empty(10)

创建元素为随机的数组

  1. # np.empty(10)的意义: 向内存要一个长度为10的内存, 并不进行赋值, 内存中原本的数据是什么就是什么, 之后可以对这个里面的值进行覆盖, 效率相对高一点
  2. arr = np.empty(10)
  3. print(arr)
  4. # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

np.eye(5)

创建单位矩阵, 方形的, 主对角线为1

  1. arr = np.eye(5)  # 类似于np.identity(5)
  2. print(arr)
  3. # [[1. 0. 0. 0. 0.]
  4. #  [0. 1. 0. 0. 0.]
  5. #  [0. 0. 1. 0. 0.]
  6. #  [0. 0. 0. 1. 0.]
  7. #  [0. 0. 0. 0. 1.]]

数组的常用方法

多维数组的转置

二维数组: 列转行

  1. two_arr = np.array([
  2.     [1, 2, 3],
  3.     [4, 5, 6],
  4.     [7, 8, 9],
  5.     [10, 11, 12]
  6. ])
  7. ret = two_arr.T
  8. print(ret)
  9. # 行: 0  列:1
  10. # [[ 1  4  7 10]
  11. #  [ 2  5  8 11]
  12. #  [ 3  6  9 12]]

三维数组的转置

  1. three_arr = np.array([
  2.     [
  3.         [1, 2, 3],
  4.         [4, 5, 6],
  5.         [7, 8, 9],
  6.         [10, 11, 12],
  7.     ],
  8.     [
  9.         [21, 22, 23],
  10.         [24, 25, 26],
  11.         [27, 28, 29],
  12.         [30, 31, 32],
  13.     ]
  14. ])
  15. # 页: 0  行:1    列:2
  16. res = three_arr.transpose(0, 2, 1)
  17. print(res)
  18. # [[[ 1  4  7 10]
  19. #   [ 2  5  8 11]
  20. #   [ 3  6  9 12]]
  21. #
  22. #  [[21 24 27 30]
  23. #   [22 25 28 31]
  24. #   [23 26 29 32]]]

矩阵的计算

创建两个矩阵

  1. a1 = np.array([
  2.     [1, 2, 3],
  3.     [4, 5, 6],
  4.     [7, 8, 9],
  5. [10, 11, 12]
  6. ])
  7.  
  8. a2 = np.array([
  9. [1, 2, 3],
  10. [4, 5, 6],
  11. [7, 8, 9],
  12. [10, 11, 12]
  13.  ])

加法

两个矩阵的结构一致才能进行加法

  1. a3 = a1 + a2
  2. print(a3)
  3. # [[ 2  4  6]
  4. #  [ 8 10 12]
  5. #  [14 16 18]
  6. #  [20 22 24]]

乘法

  1. 两个矩阵相乘, 结构必须满足以下条件才能相乘
    矩阵一的结构: 3 x 4   矩阵二的结构: 4 x 3
    n(行数) x d(列数)   d(行数) x m(列数)
    最后的结果矩阵结构就是n(行) x m(列)
  1. # 矩阵一的结构
  2. # [
  3. #     [1, 2, 3],
  4. #     [4, 5, 6],
  5. #     [7, 8, 9],
  6. #     [10, 11, 12]
  7. # ]
  8.  
  9. # 矩阵二的结构
  10. # [[ 1  4  7 10]
  11. #  [ 2  5  8 11]
  12. #  [ 3  6  9 12]]
  13.  
  14. # 相乘的结果是一个3 x 3的矩阵
  15. # 计算过程:
  16. # 矩阵一的第一行和矩阵二的第一列计算,    # 1x1 + 2x2 + 3x3 = 14
  17. # 矩阵一的第一行和矩阵二的第二列计算,    # 1x4 + 2x5 + 3x6 = 32
  18. # 矩阵一的第一行和矩阵二的第三列计算,    # 1x7 + 2x8 + 3x9 = 50
  19. # 矩阵一的第一行和矩阵二的第四列计算,
  20. # 矩阵一的第二行和矩阵二的第一列计算,
  21. # 矩阵一的第二行和矩阵二的第二列计算,
  22. # 矩阵一的第二行和矩阵二的第三列计算,
  23. # 矩阵一的第二行和矩阵二的第四列计算,
  24. # 以此类推
  25.  
  26. print(a1 @ a2.T)  # 矩阵的乘法用 @
  27. # [[ 14  32  50  68]
  28. #  [ 32  77 122 167]
  29. #  [ 50 122 194 266]
  30. #  [ 68 167 266 365]]

查看一个数组的结构　　arr.shape

一维数组

  1. one_arr = np.array([1, 2, 3, 4])
  2. print(one_arr.shape)
  3. # (4,)

二维数组

  1. a2 = np.array([
  2.     [1, 2, 3],
  3.     [4, 5, 6],
  4.     [7, 8, 9],
  5.     [10, 11, 12]
  6. ])
  7. print(a2.shape)
  8. # (4, 3)    (行, 列)

三维数组

  1. three_arr = np.array([
  2.     [
  3.         [1, 2, 3],
  4.         [4, 5, 6],
  5.         [7, 8, 9],
  6.         [10, 11, 12],
  7.     ],
  8.     [
  9.         [21, 22, 23],
  10.         [24, 25, 26],
  11.         [27, 28, 29],
  12.         [30, 31, 32],
  13.     ]
  14. ])
  15. print(three_arr.shape)
  16. # (2, 4, 3) (页, 行, 列)

获取数组中元素的个数　　arr.size

  1. one_arr = np.array([1, 2, 3, 4, 5])
  2. two_arr = np.array([
  3.     [1, 2, 3, 4],
  4.     [1, 2, 3, 4],
  5. ])
  6. three_arr = np.array([
  7.     [
  8.         [1, 2, 3, 4],
  9.         [1, 2, 3, 4],
  10.         [1, 2, 3, 4],
  11.     ],
  12.     [
  13.         [1, 2, 3, 4],
  14.         [1, 2, 3, 4],
  15.         [1, 2, 3, 4],
  16.     ]
  17. ])
  18.  
  19. print(one_arr.size)
  20. print(two_arr.size)
  21. print(three_arr.size)
  22. #
  23. #
  24. #

查看数组是几维的　　arr.ndim

  1. one_arr = np.array([1, 2, 3, 4, 5])
  2. two_arr = np.array([
  3.     [1, 2, 3, 4],
  4.     [1, 2, 3, 4],
  5. ])
  6. three_arr = np.array([
  7.     [
  8.         [1, 2, 3, 4],
  9.         [1, 2, 3, 4],
  10.         [1, 2, 3, 4],
  11.     ],
  12.     [
  13.         [1, 2, 3, 4],
  14.         [1, 2, 3, 4],
  15.         [1, 2, 3, 4],
  16.     ]
  17. ])
  18.  
  19. print(one_arr.ndim)
  20. print(two_arr.ndim)
  21. print(three_arr.ndim)
  22. #
  23. #
  24. #

查看数组中的数据的数据类型　　arr.dtype

数组中的元素类型是一致

  1. two_arr = np.array([
  2.     [1, 2, 3, 4],
  3.     [1, 2, 3, 4],
  4. ])
  5.  
  6. print(two_arr.dtype)
  7. # int32 #默认int类型是int32  最大:2147483647   最小: -2147483648

当数值正好是int32的最大最小的那个数值时, 在对这个属性进行加减, 就会从最大的回退到最小的, 最小的回退到最大的, 这是一个圈

  1. arr = np.array([0, 2 ** 31 - 1])
  2. print(arr)
  3. # [         0 2147483647]   int32最大的数值
  4. ret = arr + 1
  5. print(ret)
  6. # [          1 -2147483648] # 从最大变成了最小

如何解决这个数值太大无法表示的问题?

方法一

定义数组时, 指定大一点的数据类型,指定数据类型为int64, 或更大的object

  1. arr = np.array([0, 2 ** 31 - 1], dtype="int64")
  2. ret = arr + 10
  3. print(ret)
  4. # [        10 2147483657]

方法二

修改已经定义好数据类型的数组, 但是返回新数组, 新数组才是拥有新的数据类型的数组

  1. arr = np.array([0, 2 ** 31 - 1])
  2. new_arr = arr.astype("int64")  # 返回一个数据类型是int64的数组
  3. new_arr = new_arr + 10
  4. print(new_arr)

方法三

使用小数(float), 当要存储的数特别大时, 还可以考虑使用小数(float)的数据类型

小数的计数法不会出现计算机无法表示的问题

  1. arr = np.array([0, 2 ** 200], dtype="float")
  2. ret = arr + 200
  3. print(ret)
  4. # [2.00000000e+02 1.60693804e+60]

注意: 当生成数组时会根据你存储的值的大小动态的使用响应的数据类型, 对数据中的值进行加减时不会在改变, 因为元素的数据类型在存储时已经确定了

常用的数据类型

  1. ndarray数据类型：dtype：
  2. 布尔型：bool_
  3. 整型：int    int8    int16   int32   int 64
  4. 无符号整型：uint8   uint16  uint32  uint64  都是正数, 对int要大, 因为没有了负号
  5. 浮点型：float     float16     float32     float64
  6. 复数型：complex   complex64   complex128
  1.  

索引切片

数组索引切片的特点: python的切片会产生新的数据, 修改新数据不会影响元数据
但是在数组中却不是这样的, 切片只是在元数据上做标记, 记录3:10这一段数据B可以拿到, 当对B进行修改时
元数据也会跟着变化, 这样做的目的就是节省时间和空间, 当数据较大时, 对数据进行切片比较快
对切片后的数据使用copy()可以进行拷贝, 修改数据不会再影响元数据
one_arr[0:5].copy()

普通索引

一维数组普通索引

  1. one_arr = np.arange(10)
  2. print(one_arr)
  3. # [0 1 2 3 4 5 6 7 8 9]
  4. # 取前5个
  5. print(one_arr[0:5])
  6. # [0 1 2 3 4]

二维数组普通索引

  1. two_arr = np.arange(15).reshape(3, 5)
  2. print(two_arr)
  3. # [[ 0  1  2  3  4]
  4. #  [ 5  6  7  8  9]
  5. #  [10 11 12 13 14]]

1. 取到第二行第三列的那个数

  1. print(two_arr[2, 3])
  2. #

2. 取第一行

  1. print(two_arr[0,])
  2. # two_arr[行: 列]
  3. # [0 1 2 3 4]

3. 取第一列

  1. print(two_arr[0:,0])    # 所有的行0:    第一列0

4. 从中间去一个长方形

  1. print(two_arr[0:2, 1:4])    # 切片是前包后不包的
  2. # [[1 2 3]
  3. #  [6 7 8]]

布尔型索引

1. 问题: 给出一个数组, 选出数组中所有大于5的数
python列表的做法

  1. li = [random.randint(1, 10) for n in range(10)]
  2. # python列表的做法
  3. # res = list(filter(lambda x: x > 5, li))
  4. # print(res)

数组的做法

  1. arr = np.array(li)
  2. print(arr[arr > 5])
  3.  
  4. # 为什么这样写?
  5. # 先看看arr > 5的结果是什么
  6. print(arr > 5)
  7. # [ True  True  True  True False False  True  True  True  True]
  8. # 返回一个全是布尔的数组
  9. # 将5和原数组中的值进行比较返回布尔值
  10. # 返回使用这些布尔值进行取值, 将对应位置上是True的值取出了
  11. # arr[ True  True  True  True False False  True  True  True  True]
  12. # 这样就把结果取出来了

2. 问题: 给出一个数组, 选出所有大于5, 并且是偶数的数

  1. print(arr[(arr > 5) & (arr % 2 == 0)])
  2. # 两个条件, 当两个条件都是True时才是True
  3. # 两个条件先分别计算, 得出两个全是布尔值的数组, 然后两个数组进行 & 计算, 在使用得出的结果取原数组中取值
  4. # 注意 and    和   & 的区别
  5. # and: 是python的关键字
  6. # &: 是运算符
  7. # 在这里要使用运算符

3. 问题: 给出一个数组, 选出所有除了大于5以外的数

  1. print(arr[~(arr > 5)])
  2. # 找出大于5的, 然后使用 ~ 取反

4. 问题: 给出一个数组, 计算该数组中大于5的数字占的比重

  1. print((arr[arr > 5]).size / arr.size)
  2. # 计算出大于5的数量, 然后除以全部的数量

花式索引

给出一个数据取出索引为奇数的数值

一维数组

  1. arr = np.arange(10)
  2. print(arr[[1, 3, 5, 7, 9]])
  3. # 索引取值使用一个列表, 会取值和该列表值对应的索引位置的值, 保证列表中的元素都能作为索引, 不大于大最大索引
  4. # [1 3 5 7 9]

二维数组

  1. # 使用花式索引是, 行列不能同时使用花式索引, 例如print(arr[[1, 2], [0, 1]])
  2. arr = np.arange(15).reshape(3, 5)
  3. print(arr)
  4. # [[ 0  1  2  3  4]
  5. #  [ 5  6  7  8  9]
  6. #  [10 11 12 13 14]]
  7. # print(arr[[1, 2], :][:, [0, 1]])
  8. # [[ 5  6]
  9. #  [10 11]]

通用函数

np.abs(arr) 绝对值

  1. arr = np.arange(-5, 10).reshape(3, 5)
  2. print(arr)
  3. # [[-5 -4 -3 -2 -1]
  4. #  [ 0  1  2  3  4]
  5. #  [ 5  6  7  8  9]]
  6. print(np.abs(arr))
  7. # [[5 4 3 2 1]
  8. #  [0 1 2 3 4]
  9. #  [5 6 7 8 9]]

np.sqrt(arr) 开根号

  1. arr = np.arange(1, 16).reshape(3, 5)
  2. print(np.sqrt(arr))
  3. # [[1.         1.41421356 1.73205081 2.         2.23606798]
  4. #  [2.44948974 2.64575131 2.82842712 3.         3.16227766]
  5. #  [3.31662479 3.46410162 3.60555128 3.74165739 3.87298335]]

np.exp() 指数

  1. arr = np.arange(1, 16).reshape(3, 5)
  2. print(np.exp(arr))
  3. # [[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01
  4. #   1.48413159e+02]
  5. #  [4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03
  6. #   2.20264658e+04]
  7. #  [5.98741417e+04 1.62754791e+05 4.42413392e+05 1.20260428e+06
  8. #   3.26901737e+06]]

取整

  1. arr = np.array([3.4, 3.3, 4.6, 5.0])
  2. print(np.ceil(arr))  # 向上取整  4.5取5
  3. print(np.floor(arr))  # 向下取整  4.5取4
  4. print(np.trunc(arr))  # 向0取整
  5. print(np.rint(arr))  # 四舍五入取整

np.array()　将数组变成整数部分和小数部分两个数组

将数据分成两个数组, 一个是整数部分, 一个是小数部分, 都会带着各自的符号

  1. arr = np.array([-3.4, 3.3, -4.6, 5.0])
  2. print(np.modf(arr))
  3. # (array([-0.4,  0.3, -0.6,  0. ]), array([-3.,  3., -4.,  5.]))

isnan (not a number)

**各种没有确定值的数据运算会返回nan, 比如对-1开根号
nan不等于任何数, 自己都不等于自己

  1. a = float("nan")
  2. print(a == a)
  3. # False
  4. print(type(a), a)
  5. # <class 'float'> nan

为什么会有nan?

  1. nan常用作表示数据缺失值, 有这个值, 但是暂时不知道的值叫缺失值
  2. 因为在array进行计算时, 加入要计算一亿个数, 但是其中有一个数是没有结果的, 正常情况下会报错
  3. 那么这次计算就白做了, 但是numpy的array为了让这次计算有效, 就使用了nan

那些情况会产生nan?

  1. arr = np.array([0, 1, 2, 3])
  2. print(arr / arr)
  3. # [nan  1.  1.  1.]
  4. # 因为0/0没有结果, 就用nan代替了

判断一个数组中是否有nan

  1. arr = np.array([0, 1, 2, 3])
  2. res = arr / arr
  3. print(np.isnan(res))
  4. # [ True False False False]
  5. # 数组中的第一个元素就是nan

如何将排除数据中的nan?

  1. print(arr[~np.isnan(res)])  # 通过布尔值索引
  2. # [1 2 3]

如何将数组中的nan改为0?

  1. arr[np.isnan(res)] = 0  # 所有为True的位置写一个0
  2. print(arr)

如何创建一个nan?

  1. print(np.nan)
  2. # nan
  3. print(np.NAN)
  4. # nan

np.isinf()　　无穷大, 无穷小

inf: 无穷大, -inf: 无穷小
自己等于自己

常用的数学统计方法

常用函数

  1. arr = np.arange(10)
  2. print(arr.sum())  # 求和
  3. print(arr.mean())  # 求平局值
  4. print(arr.max())  # 最大值
  5. print(arr.min())  # 最小值
  6. print(arr.var())  # 求方差   [1,2,3,4,5]  平均值:3, ((1-3**2) + (2-3**2) + (3-3**2) + (4-3**2) + (5-3**2)) / 5(长度)
  7. print(arr.std())  # 标准差   等于方差开根号
  8. print(arr.cumsum())  # 前缀和
  9. print(arr.argmin())  # 返回最小数的索引值
  10. print(arr.argmax())  # 返回最大数的索引值

应用示例

1. 估算数组内数值的范围?

  1. arr = np.array([random.uniform(10, 20) for n in range(100)])
  2. print(arr.mean() - 2 * arr.std())  # 平均值 - 标准差
  3. # 9.024533852997003
  4. print(arr.mean() + 2 * arr.std())  # 平均值 + 标准差
  5. # 20.533572296358937

2. 求某一区间的所有数值的和

  1. arr = np.array([1, 2, 3, 7, 6, 5, 10])
  2. a = arr.cumsum()
  3. print(a)
  4. # [ 0  1  3  6 10 15 21 28 36 45]
  5. # 求索引4到索引8之间的所有数值的和 6+5=11
  6. res = a[5] - a[3]  # 顾尾不顾头
  7. print(res)
  8. #

随机数

和python的random用法基本一致, 区别在于可以直接将随机数生成到指定形状的数组中

np.random.random()

  1. print(np.random.random())  # 生产0到1之间的小数
  2. # 还可以生成到数组中
  3. # 生成一维数组
  4. print(np.random.random(10))
  5. # [0.75789864 0.49982257 0.32940952 0.57216004 0.17562665 0.50703461
  6. #  0.36919792 0.20893032 0.09530242 0.66015132]
  7.  
  8. # 生成二维数组
  9. print(np.random.random((3, 5)))
  10. # [[0.47324357 0.73385845 0.89099074 0.50889891 0.21902953]
  11. #  [0.8889513  0.48389661 0.72072126 0.36994093 0.97653365]
  12. #  [0.38499637 0.82375443 0.52682468 0.7266469  0.19659174]]

其他

  1. print(np.random.randint(10, 20, (3, 5)))  # 生成随机整数
  2. print(np.random.uniform(10, 20, (3, 5)))  # 生成随机小数, 每个数出现的次数大概相同
  3. print(np.random.normal(6, 10))  # 随机小数, 有负数, 正态分布, 中间的数出现的几率大
  4. print(np.random.choice([1, 2, 3, 4, ], 2))  # 给定的形状中随机选择, 可以指定个数
  5.  
  6. arr = np.arange(10).reshape(2, 5)
  7. np.random.shuffle(arr)  # 打乱给定形状中的数据, 打乱的是元数据
  8. print(arr)
  1.  

numpy如何使用的更多相关文章

  1. 利用Python进行数据分析(5) NumPy基础: ndarray索引和切片

    概念理解 索引即通过一个无符号整数值获取数组里的值. 切片即对数组里某个片段的描述. 一维数组 一维数组的索引 一维数组的索引和Python列表的功能类似: 一维数组的切片 一维数组的切片语法格式为a ...

  2. 利用Python进行数据分析(4) NumPy基础: ndarray简单介绍

    一.NumPy 是什么 NumPy 是 Python 科学计算的基础包,它专为进行严格的数字处理而产生.在之前的随笔里已有更加详细的介绍,这里不再赘述. 利用 Python 进行数据分析(一)简单介绍 ...

  3. 利用Python进行数据分析(6) NumPy基础: 矢量计算

    矢量化指的是用数组表达式代替循环来操作数组里的每个元素. NumPy提供的通用函数(既ufunc函数)是一种对ndarray中的数据进行元素级别运算的函数. 例如,square函数计算各元素的平方,r ...

  4. python安装numpy、scipy和matplotlib等whl包的方法

    最近装了python和PyCharm开发环境,但是在安装numpy和matplotlib等包时出现了问题,现总结一下在windows平台下的安装方法. 由于现在找不到了工具包新版本的exe文件,所以采 ...

  5. 深入理解numpy

    一.为啥需要numpy python虽然说注重优雅简洁,但它终究是需要考虑效率的.别说运行速度不是瓶颈,在科学计算中运行速度就是瓶颈. python的列表,跟java一样,其实只是一维列表.一维列表相 ...

  6. Python Numpy,Pandas基础笔记

    Numpy Numpy是python的一个库.支持维度数组与矩阵计算并提供大量的数学函数库. arr = np.array([[1.2,1.3,1.4],[1.5,1.6,1.7]])#创建ndarr ...

  7. broadcasting Theano vs. Numpy

    broadcasting Theano vs. Numpy broadcast mechanism allows a scalar may be added to a matrix, a vector ...

  8. python之numpy

    一.矩阵的拼接合并 列拼接:np.column_stack() >>> import numpy as np >>> a = np.arange(9).reshap ...

  9. win7系统下python安装numpy，matplotlib，scipy和scikit-learn

    1.安装numpy,matplotlib,scipy和scikit-learn win7系统下直接采用pip或者下载源文件进行安装numpy,matplotlib,scipy时会遇到各种问题,这是因为 ...

  10. 给numpy矩阵添加一列

    问题的定义: 首先我们有一个数据是一个mn的numpy矩阵现在我们希望能够进行给他加上一列变成一个m(n+1)的矩阵 import numpy as np a = np.array([[1,2,3], ...

随机推荐

  1. JavaScript中filter（）方法

    方法概述 用于把数组(Array)的某些元素过滤掉,然后返回剩下的元素组成的数组. 语法: var filteredArray = array.filter(callback[, thisObject ...

  2. nginx 两台机器 出现退款失败问题

    今天早上来公司后,测试人员告诉我 退款失败了.上周五还好好的,怎么这周三就出问题了,赶快让测试发来订单号,查询数据库,查询日志,发现还是以前的问题: search hit TOP, continuin ...

  3. MySQL案例02：ERROR 1221 (HY000): Incorrect usage of DB GRANT and GLOBAL PRIVILEGES

    MySQL在授权用户时出现报错信息,具体信息如下: 一.错误信息 执行命令: GRANT SELECT,INSERT, UPDATE, DELETE, CREATE, DROP, RELOAD, SH ...

  4. nginx限制IP恶意调用短信接口处理方法

    真实案例: 查看nginx日志,发现别有用心的人恶意调用API接口刷短信: /Jun/::: +] "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) ...

  5. XAMPP中Apache因为端口原因不能启动的解决方法

    在开启XAMPP的Apache时报出如下错误信息: 9:08:14 PM [Apache] Error: Apache shutdown unexpectedly.9:08:14 PM [Apache ...

  6. c++11 多线程新特性学习 (1) 管理线程

    1.基础介绍 c++11中,线程是通过std::thread对象来开始的,用法为 #include<thread> //必须包含的头文件 void do_work(){ std::cout ...

  7. Java使用iText生成word文件的完美解决方案（亲测可行）

    JAVA生成WORD文件的方法目前有以下种: 一种是jacob 但是局限于windows平台 往往许多JAVA程序运行于其他操作系统 在此不讨论该方案 一种是pio但是他的excel处理很程序 wor ...

  8. 指数循环节&欧拉降幂

    证明:https://www.cnblogs.com/maijing/p/5046628.html 注意使用条件(B的范围) 例题: FZU1759 HDU2837 ZOJ1674 HDU4335

  9. Mac iTerm2使用总结

    1.快捷键大全新建标签:command + t关闭标签:command + w切换标签:command + 数字 command + 左右方向键切换全屏:command + enter查找:comma ...

  10. Mycat数据库中间件对Mysql读写分离和分库分表配置

    Mycat是一个开源的分布式数据库系统,不同于oracle和mysql,Mycat并没有存储引擎,但是Mycat实现了mysql协议,前段用户可以把它当做一个Proxy.其核心功能是分表分库,即将一个 ...