科学计算工具Numpy
时间:2022-06-19
本文章向大家介绍科学计算工具Numpy，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。
参考学习资料：
Python、NumPy和SciPy介绍：http://cs231n.github.io/python-numpy-tutorial NumPy和SciPy快速入门：https://docs.scipy.org/doc/numpy-dev/user/quickstart.html Python的数据分析: numpy和pandas入门：http://mp.weixin.qq.com/s/2GxvBC5WWRt8eT1JnVqx1w
1.ndarray的创建与数据类型
1.Numpy（Numerical Python）
Numpy：提供了一个在Python中做科学计算的基础库，重在数值计算，主要用于多维数组（矩阵）处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。
- 高性能科学计算和数据分析的基础包
- ndarray，多维数组（矩阵），具有矢量运算能力，快速、节省空间
- 矩阵运算，无需循环，可完成类似Matlab中的矢量运算
- 线性代数、随机数生成
import numpy as np
2.ndarray 多维数组(N Dimension Array)
NumPy数组是一个多维的数组对象（矩阵），称为ndarray，具有矢量算术运算能力和复杂的广播能力，并具有执行速度快和节省空间的特点。
注意：ndarray的下标从0开始，且数组里的所有元素必须是相同类型
-
ndarray拥有的属性
- ndim属性：维度个数
- shape属性：维度大小
- dtype属性：数据类型
ndarray的随机创建
通过随机抽样 (numpy.random) 生成随机数据。
- 示例代码：
# 导入numpy，别名np
import numpy as np
# 生成指定维度大小（3行4列）的随机多维浮点型数据（二维），rand固定区间0.0 ~ 1.0
arr = np.random.rand(3, 4)
print(arr)
print(type(arr))
# 生成指定维度大小（3行4列）的随机多维整型数据（二维），randint()可以指定区间（-1, 5）
arr = np.random.randint(-1, 5, size = (3, 4)) # 'size='可省略
print(arr)
print(type(arr))
# 生成指定维度大小（3行4列）的随机多维浮点型数据（二维），uniform()可以指定区间（-1, 5）
arr = np.random.uniform(-1, 5, size = (3, 4)) # 'size='可省略
print(arr)
print(type(arr))
print('维度个数: ', arr.ndim)
print('维度大小: ', arr.shape)
print('数据类型: ', arr.dtype)- 运行结果：
[[ 0.09371338 0.06273976 0.22748452 0.49557778]
[ 0.30840042 0.35659161 0.54995724 0.018144 ]
[ 0.94551493 0.70916088 0.58877255 0.90435672]]
<class 'numpy.ndarray'>
[[ 1 3 0 1]
[ 1 4 4 3]
[ 2 0 -1 -1]]
<class 'numpy.ndarray'>
[[ 2.25275308 1.67484038 -0.03161878 -0.44635706]
[ 1.35459097 1.66294159 2.47419548 -0.51144655]
[ 1.43987571 4.71505054 4.33634358 2.48202309]]
<class 'numpy.ndarray'>
维度个数: 2
维度大小: (3, 4)
数据类型: float643.ndarray的序列创建
1. np.array(collection)
collection 为 序列型对象(list)、嵌套序列对象(list of list)。
- 示例代码：
# list序列转换为 ndarray
lis = range(10)
arr = np.array(lis)
print(arr) # ndarray数据
print(arr.ndim) # 维度个数
print(arr.shape) # 维度大小
# list of list嵌套序列转换为ndarray
lis_lis = [range(10), range(10)]
arr = np.array(lis_lis)
print(arr) # ndarray数据
print(arr.ndim) # 维度个数
print(arr.shape) # 维度大小- 运行结果：
# list序列转换为 ndarray
[0 1 2 3 4 5 6 7 8 9]
1
(10,)
# list of list嵌套序列转换为 ndarray
[[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]]
2
(2, 10)2. np.zeros()
指定大小的全0数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
3. np.ones()
指定大小的全1数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
4. np.empty()
初始化数组，不是总是返回全0，有时返回的是未初始的随机值（内存里的随机值）。
- 示例代码：
# np.zeros
zeros_arr = np.zeros((3, 4))
# np.ones
ones_arr = np.ones((2, 3))
c = np.full((2,2), 7) # Create a constant array
print(c) # Prints "[[ 7. 7.]
# [ 7. 7.]]"
d = np.eye(2) # Create a 2x2 identity matrix
print(d) # Prints "[[ 1. 0.]
# [ 0. 1.]]"
# np.empty
empty_arr = np.empty((3, 3))
# np.empty 指定数据类型
empty_int_arr = np.empty((3, 3), int)
print('------zeros_arr-------')
print(zeros_arr)
print('n------ones_arr-------')
print(ones_arr)
print('n------empty_arr-------')
print(empty_arr)
print('n------empty_int_arr-------')
print(empty_int_arr)- 运行结果：
------zeros_arr-------
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
------ones_arr-------
[[ 1. 1. 1.]
[ 1. 1. 1.]]
------empty_arr-------
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
------empty_int_arr-------
[[0 0 0]
[0 0 0]
[0 0 0]]5. np.arange() 和 reshape()
arange() 类似 python 的 range() ，创建一个一维 ndarray 数组。 reshape() 将 重新调整数组的维数。
- 示例代码：
# np.arange()
arr = np.arange(15) # 15个元素的 一维数组
print(arr)
print(arr.reshape(3, 5)) # 3x5个元素的 二维数组
print(arr.reshape(1, 3, 5)) # 1x3x5个元素的 三维数组- 运行结果：
[ 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]]
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]]6. np.arange() 和 random.shuffle()
random.shuffle() 将打乱数组序列（类似于洗牌）。
- 示例代码：
arr = np.arange(15)
print(arr)
np.random.shuffle(arr)
print(arr)
print(arr.reshape(3,5))- 运行结果：
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
[ 5 8 1 7 4 0 12 9 11 2 13 14 10 3 6]
[[ 5 8 1 7 4]
[ 0 12 9 11 2]
[13 14 10 3 6]]4.ndarray的数据类型
1. dtype参数
指定数组的数据类型，类型名+位数，如float64, int32
2.astype方法
转换数组的数据类型
- 示例代码:
# 初始化3行4列数组，数据类型为float64
zeros_float_arr = np.zeros((3, 4), dtype=np.float64)
print(zeros_float_arr)
print(zeros_float_arr.dtype)
# astype转换数据类型，将已有的数组的数据类型转换为int32
zeros_int_arr = zeros_float_arr.astype(np.int32)
print(zeros_int_arr)
print(zeros_int_arr.dtype)- 运行结果：
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
float64
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
int325.ndarray的矩阵运算
数组是编程中的概念，矩阵、矢量是数学概念。 在计算机编程中，矩阵可以用数组形式定义，矢量可以用结构定义!
1. 矢量运算：相同大小的数组间运算应用在元素上
- 示例代码：
# 矢量与矢量运算
arr = np.array([[1, 2, 3],
[4, 5, 6]])
print("元素相乘：")
print(arr * arr)
print("矩阵相加：")
print(arr + arr)- 运行结果：
元素相乘：
[[ 1 4 9]
[16 25 36]]
矩阵相加：
[[ 2 4 6]
[ 8 10 12]]2. 矢量和标量运算：“广播” - 将标量"广播"到各个元素
- 示例代码：
# 矢量与标量运算
print(1. / arr)
print(2. * arr)- 运行结果：
[[ 1. 0.5 0.33333333]
[ 0.25 0.2 0.16666667]]
[[ 2. 4. 6.]
[ 8. 10. 12.]]x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)
# Elementwise sum; both produce the array
# [[ 6.0 8.0]
# [10.0 12.0]]
print(x + y)
print(np.add(x, y))
# Elementwise difference; both produce the array
# [[-4.0 -4.0]
# [-4.0 -4.0]]
print(x - y)
print(np.subtract(x, y))
# Elementwise product; both produce the array
# [[ 5.0 12.0]
# [21.0 32.0]]
print(x * y)
print(np.multiply(x, y))
# Elementwise division; both produce the array
# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print(x / y)
print(np.divide(x, y))
# Elementwise square root; produces the array
# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print(np.sqrt(x))3.dot函数来计算向量的内积，将向量乘以矩阵，并乘以矩阵。dot既可以作为numpy模块中的函数，也可以作为数组对象的实例方法
import numpy as np
x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])
v = np.array([9,10])
w = np.array([11, 12])
# Inner product of vectors; both produce 219
print(v.dot(w))
print(np.dot(v, w))
# Matrix / vector product; both produce the rank 1 array [29 67]
print(x.dot(v))
print(np.dot(x, v))
# Matrix / matrix product; both produce the rank 2 array
# [[19 22]
# [43 50]]
print(x.dot(y))
print(np.dot(x, y))6.ndarray的索引与切片
1. 一维数组的索引与切片
与Python的列表索引功能相似
- 示例代码：
# 一维数组
arr1 = np.arange(10)
print(arr1)
print(arr1[2:5])- 运行结果：
[0 1 2 3 4 5 6 7 8 9]
[2 3 4]2. 多维数组的索引与切片：
arr[r1:r2, c1:c2]
arr[1,1] 等价 arr[1][1]
[:] 代表某个维度的数据- 示例代码：
# 多维数组
arr2 = np.arange(12).reshape(3,4)
print(arr2)
print(arr2[1])
print(arr2[0:2, 2:])
print(arr2[:, 1:3])- 运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[4 5 6 7]
[[2 3]
[6 7]]
[[ 1 2]
[ 5 6]
[ 9 10]]3. 条件索引
布尔值多维数组：arr[condition]，condition也可以是多个条件组合。 注意，多个条件组合要使用 & | 连接，而不是Python的 and or。
- 示例代码：
# 条件索引
# 找出 data_arr 中 2005年后的数据
data_arr = np.random.rand(3,3)
print(data_arr)
year_arr = np.array([[2000, 2001, 2000],
[2005, 2002, 2009],
[2001, 2003, 2010]])
is_year_after_2005 = year_arr >= 2005
print(is_year_after_2005, is_year_after_2005.dtype)
filtered_arr = data_arr[is_year_after_2005]
print(filtered_arr)
#filtered_arr = data_arr[year_arr >= 2005]
#print(filtered_arr)
# 多个条件
filtered_arr = data_arr[(year_arr <= 2005) & (year_arr % 2 == 0)]
print(filtered_arr)- 运行结果：
[[ 0.53514038 0.93893429 0.1087513 ]
[ 0.32076215 0.39820313 0.89765765]
[ 0.6572177 0.71284822 0.15108756]]
[[False False False]
[ True False True]
[False False True]] bool
[ 0.32076215 0.89765765 0.15108756]
#[ 0.32076215 0.89765765 0.15108756]
[ 0.53514038 0.1087513 0.39820313]7.ndarray的维数转换
二维数组直接使用转换函数：transpose() 高维数组转换要指定维度编号参数 (0, 1, 2, …)，注意参数是元组
- 示例代码：
arr = np.random.rand(2,3) # 2x3 数组
print(arr)
print(arr.transpose()) # 转换为 3x2 数组
arr3d = np.random.rand(2,3,4) # 2x3x4 数组，2对应0，3对应1，4对应3
print(arr3d)
print(arr3d.transpose((1,0,2))) # 根据维度编号，转为为 3x2x4 数组- 运行结果：
# 二维数组转换
# 转换前：
[[ 0.50020075 0.88897914 0.18656499]
[ 0.32765696 0.94564495 0.16549632]]
# 转换后：
[[ 0.50020075 0.32765696]
[ 0.88897914 0.94564495]
[ 0.18656499 0.16549632]]
# 高维数组转换
# 转换前：
[[[ 0.91281153 0.61213743 0.16214062 0.73380458]
[ 0.45539155 0.04232412 0.82857746 0.35097793]
[ 0.70418988 0.78075814 0.70963972 0.63774692]]
[[ 0.17772347 0.64875514 0.48422954 0.86919646]
[ 0.92771033 0.51518773 0.82679073 0.18469917]
[ 0.37260457 0.49041953 0.96221477 0.16300198]]]
# 转换后：
[[[ 0.91281153 0.61213743 0.16214062 0.73380458]
[ 0.17772347 0.64875514 0.48422954 0.86919646]]
[[ 0.45539155 0.04232412 0.82857746 0.35097793]
[ 0.92771033 0.51518773 0.82679073 0.18469917]]
[[ 0.70418988 0.78075814 0.70963972 0.63774692]
[ 0.37260457 0.49041953 0.96221477 0.16300198]]]8.ndarray的元素处理
元素计算函数
ceil(): 向上最接近的整数，参数是 number 或 array
floor():向下最接近的整数，参数是 number 或 array
rint(): 四舍五入，参数是 number 或 array
isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
multiply(): 元素相乘，参数是 number 或 array
divide(): 元素相除，参数是 number 或 array
abs():元素的绝对值，参数是 number 或 array
where(condition, x, y):三元运算符，x if condition else y
- 示例代码：
# randn() 返回具有标准正态分布的序列。
arr = np.random.randn(2,3)
print(arr)
print(np.ceil(arr))
print(np.floor(arr))
print(np.rint(arr))
print(np.isnan(arr))
print(np.multiply(arr, arr))
print(np.divide(arr, arr))
print(np.where(arr > 0, 1, -1))- 运行结果：
# print(arr)
[[-0.8350279 0.44716655 0.93326866]
[ 0.22468383 -0.48611045 0.38554865]]
# print(np.ceil(arr))
[[-0. 1. 1.]
[ 1. -0. 1.]]
# print(np.floor(arr))
[[-1. 0. 0.]
[ 0. -1. 0.]]
# print(np.rint(arr))
[[-1. 0. 1.]
[ 0. -0. 0.]]
# print(np.isnan(arr))
[[False False False]
[False False False]]
# print(np.multiply(arr, arr))
[[ 5.16284053e+00 1.77170104e+00 3.04027254e-02]
[ 5.11465231e-03 3.46109263e+00 1.37512421e-02]]
# print(np.divide(arr, arr))
[[ 1. 1. 1.]
[ 1. 1. 1.]]
# print(np.where(arr > 0, 1, -1))
[[-1 1 1]
[ 1 -1 1]]元素统计函数
1 .np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
2 .np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
3 .np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
4 .np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
5 .np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
6 .多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。
- 示例代码：
arr = np.arange(12).reshape(3,4)
print(arr)
print(np.cumsum(arr)) # 返回一个一维数组，每个元素都是之前所有元素的 累加和
print(np.sum(arr)) # 所有元素的和
print(np.sum(arr, axis=0)) # 数组的按列统计和
print(np.sum(arr, axis=1)) # 数组的按行统计和- 运行结果：
# print(arr)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# print(np.cumsum(arr))
[ 0 1 3 6 10 15 21 28 36 45 55 66]
# print(np.sum(arr)) # 所有元素的和
66
# print(np.sum(arr, axis=0)) # 0表示对数组的每一列的统计和
[12 15 18 21]
# print(np.sum(arr, axis=1)) # 1表示数组的每一行的统计和
[ 6 22 38]元素判断函数
1 .np.any(): 至少有一个元素满足指定条件，返回True
2 .np.all(): 所有的元素满足指定条件，返回True
- 示例代码：
arr = np.random.randn(2,3)
print(arr)
print(np.any(arr > 0))
print(np.all(arr > 0))- 运行结果：
[[ 0.05075769 -1.31919688 -1.80636984]
[-1.29317016 -1.3336612 -0.19316432]]
True
False元素去重排序函数
np.unique():找到唯一值并返回排序结果，类似于Python的set集合
- 示例代码：
arr = np.array([[1, 2, 1], [2, 3, 4]])
print(arr)
print(np.unique(arr))- 运行结果：
[[1 2 1]
[2 3 4]]
[1 2 3 4]- 除了使用数组计算数学函数之外，我们经常需要重新整形或以其他方式操纵数组中的数据。这种操作的最简单的例子是转置矩阵; 要转置矩阵，只需使用T数组对象的属性：
import numpy as np
x = np.array([[1,2], [3,4]])
print(x) # Prints "[[1 2]
# [3 4]]"
print(x.T) # Prints "[[1 3]
# [2 4]]"
# Note that taking the transpose of a rank 1 array does nothing:
v = np.array([1,2,3])
print(v) # Prints "[1 2 3]"
print(v.T) # Prints "[1 2 3]"9.广播
广播是一种强大的机制，允许numpy在执行算术运算时使用不同形状的数组。我们经常有一个较小的数组和一个较大的数组，我们希望多次使用较小的数组来对较大的数组执行某些操作。
例如，假设我们想要向矩阵的每一行添加一个常量向量。我们可以这样做：
import numpy as np
# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x) # Create an empty matrix with the same shape as x
# Add the vector v to each row of the matrix x with an explicit loop
for i in range(4):
y[i, :] = x[i, :] + v
# Now y is the following
# [[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]
print(y)这有效; 但是当矩阵x非常大时，在Python中计算显式循环可能会很慢。注意，将向量添加v到矩阵的每一行 x等同于vv通过堆叠v垂直的多个副本来形成矩阵，然后执行和的元素x和求和vv。我们可以像这样实现这种方法：
import numpy as np
# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1)) # Stack 4 copies of v on top of each other
print(vv) # Prints "[[1 0 1]
# [1 0 1]
# [1 0 1]
# [1 0 1]]"
y = x + vv # Add x and vv elementwise
print(y) # Prints "[[ 2 2 4
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]"Numpy广播允许我们执行此计算而无需实际创建多个副本v。考虑这个版本，使用广播：
import numpy as np
# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v # Add v to each row of x using broadcasting
print(y) # Prints "[[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]"该生产线y = x + v的工作，即使x有形状(4, 3)和v具有形状 (3,)由于广播; 这条线就像v实际上有形状一样(4, 3)，每行都是一个副本v，并且元素是按元素执行的。
将两个数组一起广播遵循以下规则：
如果数组不具有相同的等级，则将较低等级数组的形状添加为1，直到两个形状具有相同的长度。 如果两个数组在维度中具有相同的大小，或者如果其中一个数组在该维度中具有大小1，则称这两个数组在维度上是兼容的。 如果阵列在所有维度上兼容，则可以一起广播。 在广播之后，每个阵列的行为就好像它的形状等于两个输入数组的形状的元素最大值。 在一个数组的大小为1且另一个数组的大小大于1的任何维度中，第一个数组的行为就像沿着该维度复制一样
以下是广播的一些应用：
import numpy as np
# Compute outer product of vectors
v = np.array([1,2,3]) # v has shape (3,)
w = np.array([4,5]) # w has shape (2,)
# To compute an outer product, we first reshape v to be a column
# vector of shape (3, 1); we can then broadcast it against w to yield
# an output of shape (3, 2), which is the outer product of v and w:
# [[ 4 5]
# [ 8 10]
# [12 15]]
print(np.reshape(v, (3, 1)) * w)
# Add a vector to each row of a matrix
x = np.array([[1,2,3], [4,5,6]])
# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),
# giving the following matrix:
# [[2 4 6]
# [5 7 9]]
print(x + v)
# Add a vector to each column of a matrix
# x has shape (2, 3) and w has shape (2,).
# If we transpose x then it has shape (3, 2) and can be broadcast
# against w to yield a result of shape (3, 2); transposing this result
# yields the final result of shape (2, 3) which is the matrix x with
# the vector w added to each column. Gives the following matrix:
# [[ 5 6 7]
# [ 9 10 11]]
print((x.T + w).T)
# Another solution is to reshape w to be a column vector of shape (2, 1);
# we can then broadcast it directly against x to produce the same
# output.
print(x + np.reshape(w, (2, 1)))
# Multiply a matrix by a constant:
# x has shape (2, 3). Numpy treats scalars as arrays of shape ();
# these can be broadcast together to shape (2, 3), producing the
# following array:
# [[ 2 4 6]
# [ 8 10 12]]
print(x * 2)广播通常会使您的代码更简洁，更快速，因此您应该尽可能地使用它。
Numpy文档 这个简短的概述涉及了许多关于numpy需要了解的重要事项，但还远未完成。查看 numpy参考资料 ，了解有关numpy的更多信息。
10.2016年美国总统大选民意调查数据统计
项目地址：https://www.kaggle.com/fivethirtyeight/2016-election-polls
该数据集包含了2015年11月至2016年11月期间对于2016美国大选的选票数据，共27列数据
- 示例代码1 ：
# loadtxt
import numpy as np
# csv 名逗号分隔值文件
filename = './presidential_polls.csv'
# 通过loadtxt()读取本地csv文件
data_array = np.loadtxt(filename, # 文件名
delimiter=',', # 分隔符
dtype=str, # 数据类型，数据是Unicode字符串
usecols=(0,2,3)) # 指定读取的列号
# 打印ndarray数据，保留第一行
print(data_array, data_array.shape)- 运行结果：
[["b'cycle'" "b'type'" "b'matchup'"]
["b'2016'" 'b'"polls-plus"'' 'b'"Clinton vs. Trump vs. Johnson"'']
["b'2016'" 'b'"polls-plus"'' 'b'"Clinton vs. Trump vs. Johnson"'']
...,
["b'2016'" 'b'"polls-only"'' 'b'"Clinton vs. Trump vs. Johnson"'']
["b'2016'" 'b'"polls-only"'' 'b'"Clinton vs. Trump vs. Johnson"'']
["b'2016'" 'b'"polls-only"'' 'b'"Clinton vs. Trump vs. Johnson"'']] (10237, 3)- 示例代码2：
import numpy as np
# 读取列名，即第一行数据
with open(filename, 'r') as f:
col_names_str = f.readline()[:-1] # [:-1]表示不读取末尾的换行符'n'
# 将字符串拆分，并组成列表
col_name_lst = col_names_str.split(',')
# 使用的列名：结束时间，克林顿原始票数，川普原始票数，克林顿调整后票数，川普调整后票数
use_col_name_lst = ['enddate', 'rawpoll_clinton', 'rawpoll_trump','adjpoll_clinton', 'adjpoll_trump']
# 获取相应列名的索引号
use_col_index_lst = [col_name_lst.index(use_col_name) for use_col_name in use_col_name_lst]
# 通过genfromtxt()读取本地csv文件，
data_array = np.genfromtxt(filename, # 文件名
delimiter=',', # 分隔符
#skiprows=1, # 跳过第一行，即跳过列名
dtype=str, # 数据类型，数据不再是Unicode字符串
usecols=use_col_index_lst)# 指定读取的列索引号
# genfromtxt() 不能通过 skiprows 跳过第一行的
# ['enddate' 'rawpoll_clinton' 'rawpoll_trump' 'adjpoll_clinton' 'adjpoll_trump']
# 去掉第一行
data_array = data_array[1:]
# 打印ndarray数据
print(data_array[1:], data_array.shape)- 运行结果：
[['10/30/2016' '45' '46' '43.29659' '44.72984']
['10/30/2016' '48' '42' '46.29779' '40.72604']
['10/24/2016' '48' '45' '46.35931' '45.30585']
...,
['9/22/2016' '46.54' '40.04' '45.9713' '39.97518']
['6/21/2016' '43' '43' '45.2939' '46.66175']
['8/18/2016' '32.54' '43.61' '31.62721' '44.65947']] (10236, 5)SciPy
Numpy提供了一个高性能的多维数组和基本工具来计算和操作这些数组。 SciPy 以此为基础，提供了大量在numpy数组上运行的函数，可用于不同类型的科学和工程应用程序。
图像操作 SciPy提供了一些处理图像的基本功能。例如，它具有将图像从磁盘读取到numpy数组，将numpy数组作为图像写入磁盘以及调整图像大小的功能。这是一个展示这些功能的简单示例：
# -*- coding:utf-8 -*-
from scipy.misc import imread, imsave, imresize
# 将JPEG图像读入numpy数组
img = imread('image/cat.jpg')
print(img.dtype, img.shape) # Prints "uint8 (400, 248, 3)"
#我们可以通过缩放每个颜色通道来给图像着色,通过一个不同的标量常数。图像具有形状(400、248、3);
#我们将它乘以形状(3，)的数组[1,0.95,0.9];numpy广播意味着红色频道不变，并将绿色和蓝色通道分别乘以0.95和0.9分别。
img_tinted = img * [1, 0.95, 0.9]
# 调整着色图像为300 * 300像素。
img_tinted = imresize(img_tinted, (300, 300))
# 将着色后的图像写回磁盘
imsave('image/cat_tinted.jpg', img_tinted)左：原始图像。右图：着色和调整大小的图像。
MATLAB文件
功能scipy.io.loadmat和scipy.io.savemat允许您读取和写入MATLAB文件。您可以在文档中阅读它们 。
点之间的距离
SciPy定义了一些用于计算点集之间距离的有用函数。
该函数scipy.spatial.distance.pdist计算给定集合中所有点对之间的距离：
# -*- coding:utf-8 -*-
import numpy as np
from scipy.spatial.distance import pdist, squareform
#创建以下数组，其中每一行是二维空间中的一个点:
x = np.array([[0, 1], [1, 0], [2, 0]])
print(x)
# 计算所有x行之间的欧几里得距离。
# d[i, j]是x[i，:]与x[j，:]之间的欧几里得距离，和d是以下数组:
d = squareform(pdist(x, 'euclidean'))
print(d)类似的函数（scipy.spatial.distance.cdist）计算两组点之间所有对之间的距离
Matplotlib
Matplotlib是一个绘图库。本节简要介绍该matplotlib.pyplot模块，该模块提供了类似于MATLAB的绘图系统。
绘制 matplotlib中最重要的功能是plot，它允许您绘制2D数据。这是一个简单的例子：
# -*- coding:utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
# 计算正弦曲线上点的x和y坐标
x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)
# 使用matplotlib绘制这些点
plt.plot(x, y)
plt.show() # 您必须调用pl .show()来显示图形。运行此代码会生成以下图表：
通过一些额外的工作，我们可以轻松地一次绘制多条线，并添加标题，图例和轴标签：
# -*- coding:utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
# 计算正弦和余弦曲线上点的x和y坐标
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
# 使用matplotlib绘制这些点
plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('Sine and Cosine')
plt.legend(['Sine', 'Cosine'])
plt.show()您可以使用该subplot函数在同一图中绘制不同的东西。这是一个例子：
# -*- coding:utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
# 计算正弦和余弦曲线上点的x和y坐标
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
#subplot函数在同一图中绘制不同的东西
# 建立一个高度为2、宽度为1的子图网格，并将第一个子情节设置为active
plt.subplot(2, 1, 1)
# 绘制第一张图
plt.plot(x, y_sin)
plt.title('Sine')
# Set the second subplot as active, and make the second plot.
#设置第二个副情节为活动的，并制作第二个情节
plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title('Cosine')
# Show the figure.
plt.show()图片
您可以使用该imshow功能显示图像。这是一个例子：
# -*- coding:utf-8 -*-
import numpy as np
from scipy.misc import imread, imresize
import matplotlib.pyplot as plt
img = imread('image/cat.jpg')
img_tinted = img * [1, 0.95, 0.9]
# 显示原始图像
plt.subplot(1, 2, 1)
plt.imshow(img)
#subplot函数在同一图中绘制不同的东西
# 显示着色图像
plt.subplot(1, 2, 2)
#imshow的一个小问题是，它可能会产生奇怪的结果,如果显示的数据不是uint8。为了解决这个问题，我们
#在显示图像之前，显式地将图像转换为uint8。
plt.imshow(np.uint8(img_tinted))
plt.show()参考：http://www.jianshu.com/p/01109352a0b0
- ruby学习笔记(10)-puts,p,print的区别
- Linux下的Mongodb部署应用梳理
- Ocelot API网关的实现剖析
- ruby学习笔记(9)-别名(alias)与方法取消(undef,remove_method)
- Pupet自动化管理环境部署记录
- ruby学习笔记(8)-"静态方法的4种写法"与"单例方法的2种写法"
- Puppet常识梳理
- linux下增加磁盘改变指定文件路径分区挂载点和迁移数据
- 手动编写的几个简单的puppet管理配置
- 选择一款适合自己的ruby on rails IDE开发工具
- 微信的两种用途
- Sqlite快速上手使用指南
- 自动类型安全的.NET标准REST库refit
- 实现WebSocket和WAMP协议的开源库WampSharp
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法