Python 机器学习库 NumPy入门教程

NumPy是一个Python语言的软件包,它非常适合于科学计算。在我们使用Python语言进行机器学习编程的时候,这是一个非常常用的基础库。

本文是对它的一个入门教程。

介绍

NumPy是一个用于科技计算的基础软件包,它是Python语言实现的。它包含了:

  • 强大的N维数组结构
  • 精密复杂的函数
  • 可集成到C/C++和Fortran代码的工具
  • 线性代数,傅里叶变换以及随机数能力

除了科学计算的用途以外,NumPy也可被用作高效的通用数据的多维容器。由于它适用于任意类型的数据,这使得NumPy可以无缝和高效的集成到多种类型的数据库中。

获取NumPy

由于这是一个Python语言的软件包,因此需要你的机器上首先需要具备Python语言的环境。关于这一点,请自行在网络上搜索获取方法。

关于如何获取NumPy也请参阅scipy.org官网上的Installing packages。本文不再赘述。

笔者推荐使用pip的方式安装Python包,命令如下:

pip3 install numpy

本文的代码在如下的环境中验证和测试:

  • 硬件:MacBook Pro 2015
  • OS:macOS High Sierra
  • 语言环境:Python 3.6.2
  • 软件包:numpy 1.13.3

可以在这里获取到本文的所有源码:https://github.com/paulQuei/numpy_tutorial

另外,

  • 为了简单起见,本文我们会通过Python的print函数来进行结果的验证
  • 为了拼写方便,我们会默认import numpy as np

基础属性与数组创建

NumPy的基础是一个同构的多维数据,数组中的元素可以通过下标来索引。在NumPy中,维度称之为axis(复数是axes),维度的数量称之为rank。

例如:

下面是一个具有rank 1的数组,axis的长度为3:

[1, 2, 3]

下面是一个具有rank 2的数组,axis的长度也是3:

[[ 1, 2, 3],
 [ 4, 5, 6]]

我们可以通过array函数来创建NumPy的数组,例如这样:

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

请注意,这里方括号是必须的,下面这种写法是错误的:

a = np.array(1,2,3,4) # WRONG!!!

NumPy的数组类是ndarray,它有一个别名是 numpy.array,但这与Python标准库的array.array并不一样。后者仅仅是一个一维数组。而ndarray具有以下的属性:

  • ndarray.ndim:数组的维数。在Python世界中,维数称之为rank
  • ndarray.shape:数组的维度。这是一系列数字,长度由数组的维度(ndim)决定。例如:长度为n的一维数组的shape是n。一个n行m列的矩阵的shape是n,m
  • ndarray.size:数组中所有元素的数量
  • ndarray.dtype:数组中元素的类型,例如numpy.int32, numpy.int16或者numpy.float64
  • ndarray.itemsize:数组中每个元素的大小,单位为字节
  • ndarray.data:存储数组元素的缓冲。通常我们只需要通过下标来访问元素,而不需要访问缓冲

下面我们来看一下代码示例:

# create_array.py

import numpy as np

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

print('a=')
print(a)
print("a's ndim {}".format(a.ndim))
print("a's shape {}".format(a.shape))
print("a's size {}".format(a.size))
print("a's dtype {}".format(a.dtype))
print("a's itemsize {}".format(a.itemsize))
print('')
print('b=')
print(b)
print("b's ndim {}".format(b.ndim))
print("b's shape {}".format(b.shape))
print("b's size {}".format(b.size))
print("b's dtype {}".format(b.dtype))
print("b's itemsize {}".format(b.itemsize))

下面是这段代码的输出:

a=
[1 2 3]
a's ndim 1
a's shape (3,)
a's size 3
a's dtype int64
a's itemsize 8
b=
[[1 2 3]
 [4 5 6]]
b's ndim 2
b's shape (2, 3)
b's size 6
b's dtype int64
b's itemsize 8

我们也可以在创建数组的时候,指定元素的类型,例如这样:

c = np.array( [ [1,2], [3,4] ], dtype=complex )

关于array函数的更多参数说明,请参见这里:numpy.array

注:NumPy本身支持多维数组,也支持各种类型元素的数据。但考虑到,三维及以上的数组结构并不容易理解,而且我们在进行机器学习编程的时候,用的最多的是矩阵运算。因此,本文接下来的例子主要以一维和二维数字型数组来进行示例说明。

特定array的创建

在实际上的项目工程中,我们常常会需要一些特定的数据,NumPy中提供了这么一些辅助函数:

  • zeros:用来创建元素全部是0的数组
  • ones:用来创建元素全部是1的数组
  • empty:用来创建未初始化的数据,因此是内容是不确定的
  • arange:通过指定范围和步长来创建数组
  • linespace:通过指定范围和元素数量来创建数组
  • random:用来生成随机数
# create_specific_array.py

import numpy as np

a = np.zeros((2,3))
print('np.zeros((2,3)= \n{}\n'.format(a))

b = np.ones((2,3))
print('np.ones((2,3))= \n{}\n'.format(b))

c = np.empty((2,3))
print('np.empty((2,3))= \n{}\n'.format(c))

d = np.arange(1, 2, 0.3)
print('np.arange(1, 2, 0.3)= \n{}\n'.format(d))

e = np.linspace(1, 2, 7)
print('np.linspace(1, 2, 7)= \n{}\n'.format(e))

f = np.random.random((2,3))
print('np.random.random((2,3))= \n{}\n'.format(f))

这段代码的输出如下

np.zeros((2,3)=
[[ 0. 0. 0.]
 [ 0. 0. 0.]]
np.ones((2,3))=
[[ 1. 1. 1.]
 [ 1. 1. 1.]]
np.empty((2,3))=
[[ 1. 1. 1.]
 [ 1. 1. 1.]]
np.arange(1, 2, 0.3)=
[ 1. 1.3 1.6 1.9]
np.linspace(1, 2, 7)=
[ 1.  1.16666667 1.33333333 1.5  1.66666667 1.83333333
 2. ]
np.random.random((2,3))=
[[ 0.5744616 0.58700653 0.59609648]
 [ 0.0417809 0.23810732 0.38372978]]

Shape与操作

除了生成数组之外,当我们已经持有某个数据之后,我们可能会需要根据已有数组来产生一些新的数据结构,这时候我们可以使用下面这些函数:

  • reshape:根据已有数组和指定的shape,生成一个新的数组
  • vstack:用来将多个数组在垂直(v代表vertical)方向拼接(数组的维度必须匹配)
  • hstack:用来将多个数组在水平(h代表horizontal)方向拼接(数组的维度必须匹配)
  • hsplit:用来将数组在水平方向拆分
  • vsplit:用来将数组在垂直方向拆分

下面我们通过一些例子来进行说明。

为了便于测试,我们先创建几个数据。这里我们创建了:

  • zero_line:一行包含3个0的数组
  • one_column:一列包含3个1的数组
  • a:一个2行3列的矩阵
  • b:[11, 20)区间的整数数组
# shape_manipulation.py
zero_line = np.zeros((1,3))
one_column = np.ones((3,1))
print("zero_line = \n{}\n".format(zero_line))
print("one_column = \n{}\n".format(one_column))
a = np.array([(1,2,3), (4,5,6)])
b = np.arange(11, 20)
print("a = \n{}\n".format(a))
print("b = \n{}\n".format(b))

通过输出我们可以看到它们的结构:

zero_line =
[[ 0. 0. 0.]]
one_column =
[[ 1.]
 [ 1.]
 [ 1.]]
a =
[[1 2 3]
 [4 5 6]]
b =
[11 12 13 14 15 16 17 18 19]

数组b原先是一个一维数组,现在我们通过reshape方法将其调整成为一个3行3列的矩阵:

# shape_manipulation.py
b = b.reshape(3, -1)
print("b.reshape(3, -1) = \n{}\n".format(b))

这里的第二参数设为-1,表示根据实际情况自动决定。由于原先是9个元素的数组,因此调整后刚好是3X3的矩阵。这段代码输出如下:

b.reshape(3, -1) =
[[11 12 13]
 [14 15 16]
 [17 18 19]]

接着,我们通过vstack函数,将三个数组在垂直方向拼接:

# shape_manipulation.py
c = np.vstack((a, b, zero_line))
print("c = np.vstack((a,b, zero_line)) = \n{}\n".format(c))

这段代码输出如下,请读者仔细观察一下拼接前后的数据结构:

c = np.vstack((a,b, zero_line)) =
[[ 1. 2. 3.]
 [ 4. 5. 6.]
 [ 11. 12. 13.]
 [ 14. 15. 16.]
 [ 17. 18. 19.]
 [ 0. 0. 0.]]

同样的,我们也可以通过hstack进行水平方向的拼接。为了可以拼接我们需要先将数组a调整一下结构:

# shape_manipulation.py
a = a.reshape(3, 2)
print("a.reshape(3, 2) = \n{}\n".format(a))
d = np.hstack((a, b, one_column))
print("d = np.hstack((a,b, one_column)) = \n{}\n".format(d))

这段代码输出如下,请再次仔细观察拼接前后的数据结构:

a.reshape(3, 2) =
[[1 2]
 [3 4]
 [5 6]]
d = np.hstack((a,b, one_column)) =
[[ 1.  2. 11. 12. 13.  1.]
 [ 3.  4. 14. 15. 16.  1.]
 [ 5.  6. 17. 18. 19.  1.]]

请注意,如果两个数组的结构是不兼容的,拼接将无法完成。例如下面这行代码,它将无法执行:

# shape_manipulation.py
# np.vstack((a,b)) # ValueError: dimensions not match

这是因为数组a具有两列,而数组b具有3列,所以它们无法拼接。

接下来我们再看一下拆分。首先,我们将数组d在水平方向拆分成3个数组。然后我们将中间一个(下标是1)数组打印出来:

# shape_manipulation.py
e = np.hsplit(d, 3) # Split a into 3
print("e = np.hsplit(d, 3) = \n{}\n".format(e))
print("e[1] = \n{}\n".format(e[1]))

这段代码输出如下:

e = np.hsplit(d, 3) =
[array([[ 1., 2.],
    [ 3., 4.],
    [ 5., 6.]]), array([[ 11., 12.],
    [ 14., 15.],
    [ 17., 18.]]), array([[ 13.,  1.],
    [ 16.,  1.],
    [ 19.,  1.]])]
e[1] =
[[ 11. 12.]
 [ 14. 15.]
 [ 17. 18.]]

另外,假设我们设置的拆分数量使得原先的数组无法平均拆分,则操作会失败:

# np.hsplit(d, 4) # ValueError: array split does not result in an equal division

除了指定数量平均拆分,我们也可以指定列数进行拆分。下面是将数组d从第1列和第3列两个地方进行拆分:

# shape_manipulation.py
f = np.hsplit(d, (1, 3)) # # Split a after the 1st and the 3rd column
print("f = np.hsplit(d, (1, 3)) = \n{}\n".format(f))

这段代码输出如下。数组d被拆分成了分别包含1,2,3列的三个数组:

f = np.hsplit(d, (1, 3)) =
[array([[ 1.],
    [ 3.],
    [ 5.]]), array([[ 2., 11.],
    [ 4., 14.],
    [ 6., 17.]]), array([[ 12., 13.,  1.],
    [ 15., 16.,  1.],
    [ 18., 19.,  1.]])]

最后我们再将数组d在垂直方向进行拆分。同样的,如果指定的拆分数无法平均拆分则会失败:

# shape_manipulation.py
g = np.vsplit(d, 3)
print("np.hsplit(d, 2) = \n{}\n".format(g))
# np.vsplit(d, 2) # ValueError: array split does not result in an equal division
np.vsplit(d, 3)将产生三个一维数组:
np.vsplit(d, 3) =
[array([[ 1.,  2., 11., 12., 13.,  1.]]), array([[ 3.,  4., 14., 15., 16.,  1.]]), array([[ 5.,  6., 17., 18., 19.,  1.]])]

索引

接下来我们看看如何访问NumPy数组中的数据。

同样的,为了测试方便,我们先创建一个一维数组。它的内容是 [100,200)区间的整数。

最基本的,我们可以通过array[index]的方式指定下标来访问数组的元素,这一点对于有一点编程经验的人来说应该都是很熟悉的。

# array_index.py
import numpy as np
base_data = np.arange(100, 200)
print("base_data\n={}\n".format(base_data))
print("base_data[10] = {}\n".format(base_data[10]))

上面这段代码输出如下:

base_data
=[100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
 190 191 192 193 194 195 196 197 198 199]
base_data[10] = 110

在NumPy中,我们可以创建一个包含了若干个下标的数组来获取目标数组中的元素。如下所示:

# array_index.py
every_five = np.arange(0, 100, 5)
print("base_data[every_five] = \n{}\n".format(
  base_data[every_five]))

every_five是包含了我们要获取的下标的数组,它的内容大家应该很容易理解。我们可以直接通过方括号的形式来获取到所有我们指定了下标的元素,它们如下:

base_data[every_five] =
[100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180 185
 190 195]

下标数组可以是一维的,当然也可以是多维的。假设我们要获取一个2X2的矩阵,这个矩阵的内容来自于目标数组中1,2,10,20这四个下标的元素,则可以这样写:

# array_index.py
a = np.array([(1,2), (10,20)])
print("a = \n{}\n".format(a))
print("base_data[a] = \n{}\n".format(base_data[a]))

这段代码输出如下:

a =
[[ 1 2]
 [10 20]]
base_data[a] =
[[101 102]
 [110 120]]

上面我们看到的是目标数组是一维的情况,下面我们把这个数组转换成一个10X10的二维数组。

# array_index.py
base_data2 = base_data.reshape(10, -1)
print("base_data2 = np.reshape(base_data, (10, -1)) = \n{}\n".format(base_data2))

reshape函数前面已经介绍过,大家应该能够想到它的结果:

base_data2 = np.reshape(base_data, (10, -1)) =
[[100 101 102 103 104 105 106 107 108 109]
 [110 111 112 113 114 115 116 117 118 119]
 [120 121 122 123 124 125 126 127 128 129]
 [130 131 132 133 134 135 136 137 138 139]
 [140 141 142 143 144 145 146 147 148 149]
 [150 151 152 153 154 155 156 157 158 159]
 [160 161 162 163 164 165 166 167 168 169]
 [170 171 172 173 174 175 176 177 178 179]
 [180 181 182 183 184 185 186 187 188 189]
 [190 191 192 193 194 195 196 197 198 199]]

对于二维数组来说:

  • 假设我们只指定了一个下标,则访问的结果仍然是一个数组。
  • 假设我们指定了两个下标,则访问得到的是其中的元素

我们也可以通过”-1”来指定“最后一个”的元素

# array_index.py
print("base_data2[2] = \n{}\n".format(base_data2[2]))
print("base_data2[2, 3] = \n{}\n".format(base_data2[2, 3]))
print("base_data2[-1, -1] = \n{}\n".format(base_data2[-1, -1]))

这段代码输出如下。

对于更高维的数组,原理是一样的,读者可以自行推理。

base_data2[2] =
[120 121 122 123 124 125 126 127 128 129]
base_data2[2, 3] =
123
base_data2[-1, -1] =
199

除此之外,我们还可以通过”:“的形式来指定范围,例如:2:5 这样。只写”:“则表示全部范围。

请看下面这段代码:

# array_index.py
print("base_data2[2, :]] = \n{}\n".format(base_data2[2, :]))
print("base_data2[:, 3]] = \n{}\n".format(base_data2[:, 3]))
print("base_data2[2:5, 2:4]] = \n{}\n".format(base_data2[2:5, 2:4]))

它的含义是:

  • 获取下标为2的行的所有元素
  • 获取下标为3的列的所有元素

获取下标为[2,5)行,下标为[2,4)列的所有元素。请读者仔细观察一下下面的输出结果:

base_data2[2, :]] =
[120 121 122 123 124 125 126 127 128 129]
base_data2[:, 3]] =
[103 113 123 133 143 153 163 173 183 193]
base_data2[2:5, 2:4]] =
[[122 123]
 [132 133]
 [142 143]]

数学运算

NumPy中自然也少不了大量的数学运算函数,下面是一些例子,更多的函数请参见这里NumPy manual contents:

# operation.py
import numpy as np
base_data = (np.random.random((5, 5)) - 0.5) * 100
print("base_data = \n{}\n".format(base_data))
print("np.amin(base_data) = {}".format(np.amin(base_data)))
print("np.amax(base_data) = {}".format(np.amax(base_data)))
print("np.average(base_data) = {}".format(np.average(base_data)))
print("np.sum(base_data) = {}".format(np.sum(base_data)))
print("np.sin(base_data) = \n{}".format(np.sin(base_data)))

这段代码输出如下:

base_data =
[[ -9.63895991 6.9292461 -2.35654712 -48.45969283 13.56031937]
 [-39.75875796 -43.21031705 -49.27708561 6.80357128 33.71975059]
 [ 36.32228175 30.92546582 -41.63728955 28.68799187 6.44818484]
 [ 7.71568596 43.24884701 -14.90716555 -9.24092252 3.69738718]
 [-31.90994273 34.06067289 18.47830413 -16.02495202 -44.84625246]]

np.amin(base_data) = -49.277085606595726
np.amax(base_data) = 43.24884701268845
np.average(base_data) = -3.22680706079886
np.sum(base_data) = -80.6701765199715
np.sin(base_data) =
[[ 0.21254814 0.60204578 -0.70685739 0.9725159 0.8381861 ]
 [-0.88287359 0.69755541 0.83514527 0.49721505 0.74315189]
 [-0.98124746 -0.47103234 0.7149727 -0.40196147 0.16425187]
 [ 0.99045239 -0.66943662 -0.71791164 -0.18282139 -0.5276184 ]
 [-0.4741657 0.47665553 -0.36278223 0.31170676 -0.76041722]]

矩阵

接下来我们看一下以矩阵的方式使用NumPy。

首先,我们创建一个5X5的随机数整数矩阵。有两种方式可以获得矩阵的转置:通过.T或者transpose函数。另外, 通过dot函数可以进行矩阵的乘法,示例代码如下:

# matrix.py

import numpy as np

base_data = np.floor((np.random.random((5, 5)) - 0.5) * 100)
print("base_data = \n{}\n".format(base_data))

print("base_data.T = \n{}\n".format(base_data.T))
print("base_data.transpose() = \n{}\n".format(base_data.transpose()))

matrix_one = np.ones((5, 5))
print("matrix_one = \n{}\n".format(matrix_one))

minus_one = np.dot(matrix_one, -1)
print("minus_one = \n{}\n".format(minus_one))

print("np.dot(base_data, minus_one) = \n{}\n".format(
 np.dot(base_data, minus_one)))
这段代码输出如下:

base_data =
[[-49. -5. 11. -13. -41.]
 [ -6. -33. -33. -47. -4.]
 [-38. 26. 28. -18. 18.]
 [ -3. -19. -15. -39. 45.]
 [-43. 6. 18. -15. -21.]]

base_data.T =
[[-49. -6. -38. -3. -43.]
 [ -5. -33. 26. -19. 6.]
 [ 11. -33. 28. -15. 18.]
 [-13. -47. -18. -39. -15.]
 [-41. -4. 18. 45. -21.]]

base_data.transpose() =
[[-49. -6. -38. -3. -43.]
 [ -5. -33. 26. -19. 6.]
 [ 11. -33. 28. -15. 18.]
 [-13. -47. -18. -39. -15.]
 [-41. -4. 18. 45. -21.]]

matrix_one =
[[ 1. 1. 1. 1. 1.]
 [ 1. 1. 1. 1. 1.]
 [ 1. 1. 1. 1. 1.]
 [ 1. 1. 1. 1. 1.]
 [ 1. 1. 1. 1. 1.]]

minus_one =
[[-1. -1. -1. -1. -1.]
 [-1. -1. -1. -1. -1.]
 [-1. -1. -1. -1. -1.]
 [-1. -1. -1. -1. -1.]
 [-1. -1. -1. -1. -1.]]

np.dot(base_data, minus_one) =
[[ 97. 97. 97. 97. 97.]
 [ 123. 123. 123. 123. 123.]
 [ -16. -16. -16. -16. -16.]
 [ 31. 31. 31. 31. 31.]
 [ 55. 55. 55. 55. 55.]]

随机数

本文的最后,我们来看一下随机数的使用。

随机数是我们在编程过程中非常频繁用到的一个功能。例如:生成演示数据,或者将已有的数据顺序随机打乱以便分割出建模数据和验证数据。

numpy.random 包中包含了很多中随机数的算法。下面我们列举四种最常见的用法:

# rand.py
import numpy as np
print("random: {}\n".format(np.random.random(20)));
print("rand: {}\n".format(np.random.rand(3, 4)));
print("randint: {}\n".format(np.random.randint(0, 100, 20)));
print("permutation: {}\n".format(np.random.permutation(np.arange(20))));

在四种用法分别是:

  1. 生成20个随机数,它们每一个都是[0.0, 1.0)之间
  2. 根据指定的shape生成随机数
  3. 生成指定范围内([0, 100))的指定数量(20)的随机整数
  4. 对已有的数据([0, 1, 2, ..., 19])的顺序随机打乱顺序

这段代码的输出如下所示:

random: [0.62956026 0.56816277 0.30903156 0.50427765 0.92117724 0.43044905
 0.54591323 0.47286235 0.93241333 0.32636472 0.14692983 0.02163887
 0.85014782 0.20164791 0.76556972 0.15137427 0.14626625 0.60972522
 0.2995841 0.27569573]
rand: [[0.38629927 0.43779617 0.96276889 0.80018417]
 [0.67656892 0.97189483 0.13323458 0.90663724]
 [0.99440473 0.85197677 0.9420241 0.79598706]]
randint: [74 65 51 34 22 69 81 36 73 35 98 26 41 84 0 93 41 6 51 55]
permutation: [15 3 8 18 14 19 16 1 0 4 10 17 5 2 6 12 9 11 13 7]

总结

以上所述是小编给大家介绍的Python 机器学习库 NumPy入门教程,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!

您可能感兴趣的文章:

  • python机器学习库常用汇总
  • python中numpy.zeros(np.zeros)的使用方法
  • python学习教程之Numpy和Pandas的使用
  • python中numpy基础学习及进行数组和矢量计算
  • Python科学计算之NumPy入门教程
  • Python NumPy库安装使用笔记
  • Python中优化NumPy包使用性能的教程
  • Python中的Numpy入门教程
时间: 2018-04-18

python中numpy.zeros(np.zeros)的使用方法

翻译: 用法:zeros(shape, dtype=float, order='C') 返回:返回来一个给定形状和类型的用0填充的数组: 参数:shape:形状 dtype:数据类型,可选参数,默认numpy.float64 dtype类型: t ,位域,如t4代表4位 b,布尔值,true or false i,整数,如i8(64位) u,无符号整数,u8(64位) f,浮点数,f8(64位) c,浮点负数, o,对象, s,a,字符串,s24 u,unicode,u24 order:可选参数

Python NumPy库安装使用笔记

1. NumPy安装 使用pip包管理工具进行安装 复制代码 代码如下: $ sudo pip install numpy 使用pip包管理工具安装ipython(交互式shell工具) 复制代码 代码如下: $ sudo pip instlal ipython $ ipython --pylab  #pylab模式下, 会自动导入SciPy, NumPy, Matplotlib模块 2. NumPy基础 2.1. NumPy数组对象 具体解释可以看每一行代码后的解释和输出 复制代码 代码如下:

Python科学计算之NumPy入门教程

前言 NumPy是Python用于处理大型矩阵的一个速度极快的数学库.它允许你在Python中做向量和矩阵的运算,而且很多底层的函数都是用C写的,你将获得在普通Python中无法达到的运行速度.这是由于矩阵中每个元素的数据类型都是一样的,这也就减少了运算过程中的类型检测. 矩阵基础 在 numpy 包中我们用数组来表示向量,矩阵和高阶数据结构.他们就由数组构成,一维就用一个数组表示,二维就是数组中包含数组表示. 创建 # coding: utf-8 import numpy as np a =

python机器学习库常用汇总

汇总整理一套Python网页爬虫,文本处理,科学计算,机器学习和数据挖掘的兵器谱. 1. Python网页爬虫工具集 一个真实的项目,一定是从获取数据开始的.无论文本处理,机器学习和数据挖掘,都需要数据,除了通过一些渠道购买或者下载的专业数据外,常常需要大家自己动手爬数据,这个时候,爬虫就显得格外重要了,幸好,Python提供了一批很不错的网页爬虫工具框架,既能爬取数据,也能获取和清洗数据,也就从这里开始了: 1.1 Scrapy 鼎鼎大名的Scrapy,相信不少同学都有耳闻,课程图谱中的很多课

python学习教程之Numpy和Pandas的使用

前言 本文主要给大家介绍了关于python中Numpy和Pandas使用的相关资料,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 它们是什么? NumPy是Python语言的一个扩充程序库.支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库. Pandas是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的.Pandas 纳入了大量库和一些标准的数据模型,提供了高效地操作大型数据集所需的工具.Pandas提供了大量能使我们快速便捷地处理数据

python中numpy基础学习及进行数组和矢量计算

前言 在python 中有时候我们用数组操作数据可以极大的提升数据的处理效率,类似于R的向量化操作,是的数据的操作趋于简单化,在python 中是使用numpy模块可以进行数组和矢量计算. 下面来看下简单的例子 import numpy as np data=np.array([2,5,6,8,3]) #构造一个简单的数组 print(data) 结果: [2 5 6 8 3] data1=np.array([[2,5,6,8,3],np.arange(5)]) #构建一个二维数组 print(

Python中的Numpy入门教程

1.Numpy是什么 很简单,Numpy是Python的一个科学计算的库,提供了矩阵运算的功能,其一般与Scipy.matplotlib一起使用.其实,list已经提供了类似于矩阵的表示形式,不过numpy为我们提供了更多的函数.如果接触过matlab.scilab,那么numpy很好入手. 在以下的代码示例中,总是先导入了numpy: 复制代码 代码如下: >>> import numpy as np>>> print np.version.version1.6.2

Python中优化NumPy包使用性能的教程

NumPy是Python中众多科学软件包的基础.它提供了一个特殊的数据类型ndarray,其在向量计算上做了优化.这个对象是科学数值计算中大多数算法的核心. 相比于原生的Python,利用NumPy数组可以获得显著的性能加速,尤其是当你的计算遵循单指令多数据流(SIMD)范式时.然而,利用NumPy也有可能有意无意地写出未优化的代码. 在这篇文章中,我们将看到一些技巧,这些技巧可以帮助你编写高效的NumPy代码.我们首先看一下如何避免不必要的数组拷贝,以节省时间和内存.因此,我们将需要深入Num

python中pip的安装与使用教程

在安装pip前,请确认win系统中已经安装好了python,和easy_install工具,如果系统安装成功,easy_install在目录python的安装盘(如C盘):\Python27\Scripts下面 2.采用cd命令进入到Scripts 目录下面:G:\Python27\Scripts 3.输入命令: easy_install pip,开始安装pip 4. pip安装成功后,在cmd下执行pip,将会有如下提示. 5. pip 是一个安装和管理 Python包的工具,下载相关pyth

Python 中的pygame安装与配置教程详解

安装软件环境及版本说明 OS: Win10 x 64 专业版 Python: 2.7 IDE: PyCharm Community 2018 1. 安装python 1)下载并安装python python官网下载需要的版本,并安装(安装过程很简单,步骤略) https://www.python.org/downloads/windows/ 这里下载的是python2.7 2)配置环境变量 如果安装python时,没有勾选添加python到环境变量PATH,则需要手动添加 3)验证是否安装+配置

python中format()函数的简单使用教程

先给大家介绍下python中format函数,在文章下面给大家介绍python.format()函数的简单使用 ---恢复内容开始--- python中format函数用于字符串的格式化 通过关键字 print('{名字}今天{动作}'.format(名字='陈某某',动作='拍视频'))#通过关键字 grade = {'name' : '陈某某', 'fenshu': '59'} print('{name}电工考了{fenshu}'.format(**grade))#通过关键字,可用字典当关键

在python中利用numpy求解多项式以及多项式拟合的方法

构建一个二阶多项式:x^2 - 4x + 3 多项式求解 >>> p = np.poly1d([1,-4,3]) #二阶多项式系数 >>> p(0) #自变量为0时多项式的值 3 >>> p.roots #多项式的根 array([3., 1.]) >>> p(p.roots) #多项式根处的值 array([0., 0.]) >>> p.order #多项式的阶数 2 >>> p.coeffs #

python中利用numpy.array()实现俩个数值列表的对应相加方法

小编想把用python将列表[1,1,1,1,1,1,1,1,1,1] 和 列表 [2,2,2,2,2,2,2,2,2,2]对应相加成[3,3,3,3,3,3,3,3,3,3]. 代码如下: import numpy a = numpy.array([1,1,1,1,1,1,1,1,1,1]) b = numpy.array([2,2,2,2,2,2,2,2,2,2]) c = a + b print(type(c)) print(list(c)) 输出结果为: <class 'numpy.nd

python中class的定义及使用教程

类的定义 class classname[(父类名)]: – 成员函数及成员变量 _ init _ 构造函数:初始化对象 _ del_ 析构函数:销毁对象 定义类的成员函数时,必须默认一个变量代表类定义的对象本身,这个变量的名称可自行定义,下面的程序使用self变量表示类对象的变量 具体代码如下所示: python中class的定义及使用 #类(Class): 用来描述具有相同的属性和方法的对象的集合.它定义了该集合中每个对象所共有的属性和方法. #对象:它是类的实例化. #方法:类中定义的函数

python中的turtle库函数简单使用教程

具体内容如下所示: 参考案例: import turtle d=0 for i in range(4): turtle.fd(200) #或者写成turtle.forward(200) d =d+90 turtle.seth(d) #改变角度,可以写成turtle.setheading(to_angle) 总结 以上所述是小编给大家介绍的python中的turtle库函数简单使用教程,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的.在此也非常感谢大家对我们网站的支持! 如

在python中利用pycharm自定义代码块教程(三步搞定)

当我们在使用pycharm时,输入特殊的关键字会有提示,然后按enter就可以自动补全,如果我们经常需要输出重复的代码时,能否也利用这种方法来自动补全呢? 下面我们就来利用pycharm自定义代码块: 1.打开pycharm中file下的setting,找到Editor下面的Live Templates ,右侧就会出现各种语言的代码块,我们选择Python,点击右侧的"+",选择Live Template 2.Abbreviation就是你自定义代码块的名字,Description是描

Python中random模块常用方法的使用教程

前言 Python 的random模块包含许多随机数生成器. random是Python标准库之一,直接导入即可使用.本文介绍random中常用方法的用法. 一.生成随机的整数 # coding=utf-8 import random print(random.randint(1, 5)) print(random.randrange(0, 51, 5)) 运行结果: 3 40 randint(start, end)会返回一个start到end之间的整数,这里是左闭右闭区间.也就是说可能会返回e