jupyter notebook第三章numpy库的一些案例分析加相关函数的解析

NumPy 是在 1995 年诞生的 Python 库 Numeric 的基础上建立起来的，但真正促使 NumPy 的发行的是 Python 的 SciPy 库。但 SciPy 中并没有合适的类似于 Numeric 中的对于基础数据对象处理的功能。于是， SciPy 的开发者将 SciPy 中的一部分和 Numeric 的设计思想结合，在 2005 年发行了 NumPy 。

v NumPy 是 Python 的一种开源的数值计算扩展库。它包含很多功能，如创建 n 维数组（矩阵）、对数组进行函数运算、数值积分等。 NumPy 的诞生弥补了这些缺陷，它提供了两种基本的对象：

ndarray ：是储存单一数据类型的多维数组。

ufunc ：是一种能够对数组进行处理的函数。

NumPy 常用的导入格式： import numpy as np

以下是对numpy的一些案例与相关函数的介绍：

例3-1

In [1]:

import numpy as np

datal = [1,3,5,7]

w1 = np.array(datal)#1.列表

print("w1:",w1)

data2 = (2,4,6,8)

w2 = np.array(data2)#2.元组

print("w2:",w2)

data3 = [[1,2,3,4],[5,6,7,8]]

w3 = np.array(data3)#3.多维数组

print("w3:",w3)

w1: [1 3 5 7]
w2: [2 4 6 8]
w3: [[1 2 3 4]
 [5 6 7 8]]

as np 引入模块的别名

例3-2

In [2]:

w3 = np.array([1,2,3,4],dtype = 'float32')

print(w3.dtype)

float32

补充说明：

range()函数

函数说明： range(start, stop[, step]) -> range object，根据start与stop指定的范围以及step设定的步长，生成一个序列。

参数含义：

start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;

end:技术到end结束，但不包括end.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

scan：每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

函数返回的是一个range object

例3-3——例3-9

创建数组的函数应用

In [3]:

warray = np.arange(10)

print(warray)#默认开始为0，结束值是10，默认步长1，

[0 1 2 3 4 5 6 7 8 9]

In [4]:

warray = np.arange(0,1,0.2)#不包含1

print(warray)#默认开始为0，结束值是1，步长0.2，

[0.  0.2 0.4 0.6 0.8]

arange函数：创建等差一维数组

格式：np.arange([start, ]stop, [step, ]dtype)

参数说明：

start参数为起始点，默认为0

stop参数为结束值；生成的元素不包括结束值

step参数为步长，可省略，默认步长为1；【未指明生成的数的个数】

dtype参数可以设置元素的数据类型，默认使用输入数据的类型

In [6]:

warray = np.linspace(0,1,5)#num【精确生成几个数】包含1

print(warray)

[0.   0.25 0.5  0.75 1.  ]

linspace 函数：创建等差一维数组，接收元素数量作为参数。

格式：np.linspace(start, stop, num, endpoint, retstep=False, dtype=None)

参数说明：

start参数为起始点，默认为0

stop参数为结束值；生成的元素不包括结束值

num要生成的等间隔样例数量

In [7]:

warray = np.logspace(0,1,5)#生成1-10之间具有5个元素的等比数列

print(warray)

[ 1.          1.77827941  3.16227766  5.62341325 10.        ]

logspace函数：创建等比一维数组

格式：np.logspace(start, stop, num, endpoint=True, base=10.0, dtype=None))

logspace的参数中，start, stop代表的是10的幂,默认基数base为10，第三个参数元素个数

In [8]:

print(np.zeros(4))

print(np.zeros([3,3]))

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

zeros函数：创建指定长度或形状的全0数组

格式：np.zeros(shape, dtype=float, order='C')

In [9]:

print(np.ones(5))

print(np.ones([2,3]))

[1. 1. 1. 1. 1.]
[[1. 1. 1.]
 [1. 1. 1.]]

ones函数：创建指定长度或形状的全1数组

格式：np. ones(shape, dtype=None, order='C')

In [10]:

print(np.eye(5))

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

np.eye() np.eye()的函数 ，除了生成对角阵外，还可以将一个label数组，大小为 (1,m) 或者 (m,1)的 数组，转化成one-hot数组

​第一个参数：输出方阵（行数=列数）的规模，即行数或列数

第三个参数：默认情况下输出的是对角线全“1”，其余全“0”的方阵，如果k为正整数，则在右上方第k条对角线全“1”其余全“0”，k为负整数则在左下方第k条对角线全“1”其余全“0”。

np.eye()

函数的原型：numpy.eye(N,M=None,k=0,dtype=<class ‘float’>,order='C)

返回的是一个二维2的数组(N,M)，对角线的地方为1，其余的地方为0.

参数介绍：

（1）N:int型，表示的是输出的行数

（2）M：int型，可选项，输出的列数，如果没有就默认为N

（3）k：int型，可选项，对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角。

（4）dtype：数据的类型，可选项，返回的数据的数据类型

（5）order：{‘C’，‘F’}，可选项，也就是输出的数组的形式是按照C语言的行优先’C’，还是按照Fortran形式的列优先‘F’存储在内存中

In [2]:

#关于eye的高级案例

import numpy as np

labels=np.array([[1],[2],[0],[1]])

print("labels的大小:",labels.shape,"\n")

#因为我们的类别是从0-2，所以这里是3个类

a=np.eye(3)[1]

print("如果对应的类别号是1，那么转成one-hot的形式",a,"\n")

a=np.eye(3)[2]

print("如果对应的类别号是2，那么转成one-hot的形式",a,"\n")

a=np.eye(3)[1,0]

print("1转成one-hot的数组的第一个数字是：",a,"\n")

#这里和上面的结果的区别，注意!!!

a=np.eye(3)[[1,2,0,1]]

print("如果对应的类别号是1,2,0,1，那么转成one-hot的形式\n",a)

res=np.eye(3)[labels.reshape(-1)]

print("labels转成one-hot形式的结果：\n",res,"\n")

print("labels转化成one-hot后的大小：",res.shape)

labels的大小: (4, 1) 

如果对应的类别号是1，那么转成one-hot的形式 [0. 1. 0.] 

如果对应的类别号是2，那么转成one-hot的形式 [0. 0. 1.] 

1转成one-hot的数组的第一个数字是： 0.0 

如果对应的类别号是1,2,0,1，那么转成one-hot的形式
 [[0. 1. 0.]
 [0. 0. 1.]
 [1. 0. 0.]
 [0. 1. 0.]]
labels转成one-hot形式的结果：
 [[0. 1. 0.]
 [0. 0. 1.]
 [1. 0. 0.]
 [0. 1. 0.]] 

labels转化成one-hot后的大小： (4, 3)

In [11]:

print(np.diag([3,4,5]))

[[3 0 0]
 [0 4 0]
 [0 0 5]]

diag函数：创建一个对角阵。

格式：np.diag(v, k=0)

例3-10——例3-12

In [5]:

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

print('秩为：',warray.ndim)

print('形状为：',warray.shape)

print('大小为：',warray.size)

秩为： 2
形状为： (2, 3)
大小为： 6

In [6]:

warray.shape = 3,2#数据转换的shape属性，直接转换为三行两列的数组

print(warray)

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

In [9]:

arr1 = np.arange(6)

print(arr1)

print(arr1.dtype)

arr2 = arr1.astype(np.float64)#astype进行数据类型的转换

print(arr2)

print(arr2.dtype)

[0 1 2 3 4 5]
int32
[0. 1. 2. 3. 4. 5.]
float64

例3-13，3-14

In [5]:

arr = np.random.randint(100,200,size = (2,4))

print(arr)

[[104 127 181 135]
 [147 174 171 189]]

In [4]:

import numpy as np

在NumPy.random模块中，提供了多种随机数的生成函数。如randint函数生成指定范围的随机【整数】来构成指定形状的数组。 用法：np.random.randint(low, high = None, size = None)

seed函数——确定随机数生成器的种子

permutation函数——返回一个序列的随机排列或返回一个随机排列的范围

shuffle函数——对一个序列进行随机排序

binomial函数——产生二项分布的随机数

normal函数——产生正态（高斯）分布的随机数

beta函数——产生beta分布的随机数

chisquare函数——产生卡方分布的随机数

gamma函数——产生gamma分布的随机数

uniform函数——产生在[0,1)中均匀分布的随机数

In [15]:

np.random.seed(3)

arr1 = np.random.rand(5)#生成0-1之间的【float小数】

print(arr1)

arr2 = np.random.rand(4,2)#生成四行两列的随机数

print(arr2)

[0.5507979  0.70814782 0.29090474 0.51082761 0.89294695]
[[0.89629309 0.12558531]
 [0.20724288 0.0514672 ]
 [0.44080984 0.02987621]
 [0.45683322 0.64914405]]

np.random.rand(d0,d1,d2……dn) 

注：使用方法与np.random.randn()函数相同 

作用： 

通过本函数可以返回一个或一组服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1。 

应用：在深度学习的Dropout正则化方法中，可以用于生成dropout随机向量（dl），例如（keep_prob表示保留神经元的比例）：dl = np.random.rand(al.shape[0],al.shape[1]) < keep_prob

​

np.random.randn(d0,d1,d2……dn) 

1)当函数括号内没有参数时，则返回一个浮点数； 

2）当函数括号内有一个参数时，则返回秩为1的数组，不能表示向量和矩阵； 

3）当函数括号内有两个及以上参数时，则返回对应维度的数组，能表示向量或矩阵； 

4）np.random.standard_normal（）函数与np.random.randn()类似，但是np.random.standard_normal（）

的输入参数为元组（tuple）. 

5)np.random.randn()的输入通常为整数，但是如果为浮点数，则会自动直接截断转换为整数。

作用：通过本函数可以返回一个或一组服从标准正态分布的随机样本值。

标准正态分布曲线下面积分布规律是：

在-1.96～+1.96范围内曲线下的面积等于0.9500（即取值在这个范围的概率为95%），在-2.58～+2.58范围内曲线下面积为0.9900（即取值在这个范围的概率为99%）. 

因此，由 np.random.randn()函数所产生的随机样本基本上取值主要在-1.96~+1.96之间，当然也不排除存在较大值的情形，只是概率较小而已。

1. 利用array函数创建数组对象
2. 专门创建数组的函数——arange函数、linspace 函数、logspace函数、zeros函数、ones函数、diag函数、eye函数
3. 使用随机数生成random函数

例3-15——3-17

In [17]:

arr1 = np.arange(8)#生成0-7的随机数组

print(arr1)

arr2 = arr1.reshape(4,2)#注意的一点，使用resahpe函数要将数组【重新赋值给新的变量数组】

print(arr2)

[0 1 2 3 4 5 6 7]
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

对于定义好的数组，可以通过reshape方法改变其数据维度。

格式：np.reshape(a, newshape, order='C')

参数说明：

a——需要处理的数据

newshape——新维度—整数或者整数元组

reshape的参数中的其中一个可以设置为-1，表示数组的维度可以通过数据本身来推断。

In [18]:

arr1 = np.arange(12)

print('arr1:',arr1)

arr2 = arr1.reshape(2,-1)#-1，表示【数组的维度可以通过数据本身来推断】。应用于数组较多，维度较多的情况

print('arr2:',arr2)

arr1: [ 0  1  2  3  4  5  6  7  8  9 10 11]
arr2: [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

In [20]:

arr1 = np.arange(12).reshape(3,4)

print('arr1:',arr1)

arr2 = arr1.ravel()#数据散开

print('arr2:',arr2)#重塑之后的视图，并不会改变arr1

arr3 = arr1.flatten()#数据扁平化

print('arr3:',arr3)

arr1: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr2: [ 0  1  2  3  4  5  6  7  8  9 10 11]
arr3: [ 0  1  2  3  4  5  6  7  8  9 10 11]

与reshape相反的方法是数据散开（ravel）或数据扁平化（flatten）。 两个实现的功能一样

例3-18——3-24

In [24]:

arr1 = np.arange(6).reshape(3,2)

arr2 = arr1 * 2

print('arr1:',arr1)

print('arr2:',arr2)

arr3 = np.hstack((arr1,arr2))#横向合并

print('arr3:',arr3)

arr4 = np.vstack((arr1,arr2))#纵向合并

print('arr4:',arr4)

arr1: [[0 1]
 [2 3]
 [4 5]]
arr2: [[ 0  2]
 [ 4  6]
 [ 8 10]]
arr3: [[ 0  1  0  2]
 [ 2  3  4  6]
 [ 4  5  8 10]]
arr4: [[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 0  2]
 [ 4  6]
 [ 8 10]]

hstack函数：实现横向合并 vstack函数：实现纵向组合是利用vstack将数组纵向合并； concatenate函数：可以实现数组的横向或纵向合并，参数axis=1时进行横向合并，axis=0时进行纵向合并。 与数组合并相反，hsplit函数、vsplit函数和split函数分别实现数组的横向、纵向和指定方向的分割。

In [25]:

arr1 = np.arange(6).reshape(3,2)

arr2 = arr1 * 2

#参数axis=1时进行横向合并，axis=0时进行纵向合并。

print('横向合并为：',np.concatenate((arr1,arr2),axis = 1))#轴

print('纵向合并为：',np.concatenate((arr1,arr2),axis = 0))

横向合并为： [[ 0  1  0  2]
 [ 2  3  4  6]
 [ 4  5  8 10]]
纵向合并为： [[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 0  2]
 [ 4  6]
 [ 8 10]]

In [8]:

arr = np.arange(16).reshape(4,4)

print('arr:\n',arr)

print('\n',np.hsplit(arr,2))#横向分割

print(np.vsplit(arr,4))#纵向分割

arr:
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

 [array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

In [10]:

arr = np.arange(16).reshape(4,4)

print('arr:\n',arr)

print(np.split(arr,2,axis = 1))#指定方向的分割，分割为两个，横向分割

print(np.split(arr,4,axis = 0))#指定方向的分割，分割为四个，纵向分割

arr:
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

In [11]:

arr = np.arange(6).reshape(3,2)

print(arr)

print(arr.transpose(1,0))#表示行与列调换了位置

print(arr.transpose(0,1))#表示列与行调换了位置

[[0 1]
 [2 3]
 [4 5]]
[[0 2 4]
 [1 3 5]]
[[0 1]
 [2 3]
 [4 5]]

数组转置是数组重塑的一种特殊形式，可以通过transpose方法进行转置。 除了使用transpose外，可以直接利用数组的T属性进行数组转置。 二维矩阵的transpose函数： transpose（X，Y）函数和矩阵的转置是一个意思，相当于行为X轴，列为Y轴，X轴和Y轴调换了位置；X轴用0表示，Y轴用1表示；

三维张量的transpose函数： 前面我们讲了二维矩阵的transpose函数其实是和矩阵的转置是一个概念； 三维张量顾名思义，它有三个维度；相当于有X轴，Y轴，Z轴；三个轴之间的相互转换；同样，X轴用0表示，Y轴用1表示；Z轴用2来表示；

补充：transpose三维张量

In [19]:

arr = np.arange(24).reshape((2, 3, 4))

print('arr:',arr)

arr1 = arr.transpose(1,0,2)#表示X轴与Y轴发生变换之后

print('arr1:',arr1)

arr2 = arr.transpose(0,2,1)#表示Y轴与Z轴发生轴变换之后

print('arr2:',arr2)

arr3 = arr.transpose(2,1,0)#表示X轴与Z轴发生变换之后

print('arr3:',arr3)

arr: [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
arr1: [[[ 0  1  2  3]
  [12 13 14 15]]

 [[ 4  5  6  7]
  [16 17 18 19]]

 [[ 8  9 10 11]
  [20 21 22 23]]]
arr2: [[[ 0  4  8]
  [ 1  5  9]
  [ 2  6 10]
  [ 3  7 11]]

 [[12 16 20]
  [13 17 21]
  [14 18 22]
  [15 19 23]]]
arr3: [[[ 0 12]
  [ 4 16]
  [ 8 20]]

 [[ 1 13]
  [ 5 17]
  [ 9 21]]

 [[ 2 14]
  [ 6 18]
  [10 22]]

 [[ 3 15]
  [ 7 19]
  [11 23]]]

In [32]:

arr = np.arange(6).reshape(3,2)

print(arr)

print(arr.T)

[[0 1]
 [2 3]
 [4 5]]
[[0 2 4]
 [1 3 5]]

1、transpose 按照多维数组的轴的索引进行变换

2、swapaxes 对轴进行两两置换，swapaxes实际上也是针对轴索引进行变化，区别就在于transpose可以一次搞三个，但是swapaxes只能两两置换。

对于swapaxes来说，括号内的两参数，交换位置和不交换，实际结果相同。

arr.swapaxes(1,2)（实际上等价于arr.swapaxes(2,1)）

In [33]:

arr = np.arange(6).reshape(3,2)

print(arr)

print(arr.swapaxes(0,1))

[[0 1]
 [2 3]
 [4 5]]
[[0 2 4]
 [1 3 5]]

一维数组的索引与切片

例3-28——3-35

In [20]:

arr = np.arange(10)

print(arr)

print(arr[-1])#索引   一维数组的索引类似Python中的列表

print(arr[1:4])#1-4但是不包含4

[0 1 2 3 4 5 6 7 8 9]
9
[1 2 3]

In [22]:

arr1 = arr[-4:-1].copy()#-4到-1但是不包括-1  copy就是复制一下

#不论是索引还是切片，返回的都是视图

print(arr)

print(arr1)

[0 1 2 3 4 5 6 7 8 9]
[6 7 8]

数组的切片返回的是原始数组的视图，不会产生新的数据，如果需要的并非视图而是要复制数据，则可以通过copy方法实现

多维数组的索引与切片

In [23]:

arr = np.arange(12).reshape(3,4)#0-11重塑为三行四列

print(arr)

print(arr[0,1:3])#索引第0行和第一列到第二列的元素

print(arr[:,2])#索引第二列的元素   :指取横向所有的行   纵向只取第2列

print(arr[:1,:1])#第0行和第0列的元素

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

对于多维数组，它的每一个维度都有一个索引，各个维度的索引之间用逗号分隔。

也可以使用整数函数和布尔值索引访问多维数组。

In [6]:

arr = np.arange(12).reshape(3,4)#从两个序列的对应位置取出两个整数来组成下标：

print(arr)

print('取出（0，1）和（1，3）位置的元素：',arr[(0,1),(1,3)])#整数函数和布尔值索引访问多维数组

print('取出第1行的第0、第2、第3列的元素：',arr[1:2,(0,2,3)])

mask = np.array([1,0,1],dtype = np.bool_)#布尔值索引   mask是一个布尔数组，它索引第0,2行中第1列元素

print('索引第0,2行中第1列元素:',arr[mask,1])

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
取出（0，1）和（1，3）位置的元素： [1 7]
取出第1行的第0、第2、第3列的元素： [[4 6 7]]
索引第0,2行中第1列元素: [1 9]

通过逻辑判断符号可以得到一个mask掩码,其值是True或者False,并且维度和原来的多维数组相同.使用mask来索引得到的是一个一维数组,筛选出True位置对应的元素.通过mask掩码就可以对原多维数组进行修改.但是如果将mask筛选出的内容赋值给一个变量的话,无法通过这个变量来修改原来的多维数组,他们互不影响.

​

布尔型索引指的是一个布尔型ndarray数组（一般为一维）对应另一个ndarray数组的每行，布尔型数组的个数要必须与另一个多维数组的行数一致。若布尔型数组内的某个元素为True，则选取另一个多维数组的行，反之不选取。

布尔型切片——跟多维数组的切片类似，[行, 列]第一个为行，第二个为列切片。

补充

In [8]:

import numpy as np

zarten = np.random.randn(5,4)

print(zarten)

print('*' * 50)

zarten_bool = np.array([True, False, False, False, True])

print(zarten[zarten_bool])

[[ 0.46455416 -0.04155029  1.49515367  0.21440467]
 [-1.13439641  0.63211808 -0.99007615 -0.54329061]
 [-2.17630906  0.1469423  -0.78419055 -1.91294766]
 [-1.52338543  1.05080577  1.90935584 -0.45517976]
 [-1.029445   -0.33022017 -1.14776608 -1.64167453]]
**************************************************
[[ 0.46455416 -0.04155029  1.49515367  0.21440467]
 [-1.029445   -0.33022017 -1.14776608 -1.64167453]]

In [7]:

import numpy as np

​

zarten = np.random.randn(5,4)

print(zarten)

print('*' * 50)

​

#选取第一行和第二行

​

#布尔型索引做法

zarten_bool = np.array([True, True, False, False, False])

print(zarten[zarten_bool])

print('*' * 50)

​

#花式索引做法

print(zarten[[0, 1]])

[[-0.92204841 -0.1404135   0.40789412 -0.1261898 ]
 [-0.70808352  0.69545793 -0.27338531 -1.13466276]
 [-0.23422135  0.39316227  0.10975406  0.39738821]
 [ 0.28297144 -1.19208851 -1.42972672 -0.04864867]
 [-0.46654196  0.43460753  0.61013137 -0.4527327 ]]
**************************************************
[[-0.92204841 -0.1404135   0.40789412 -0.1261898 ]
 [-0.70808352  0.69545793 -0.27338531 -1.13466276]]
**************************************************
[[-0.92204841 -0.1404135   0.40789412 -0.1261898 ]
 [-0.70808352  0.69545793 -0.27338531 -1.13466276]]

花式索引跟布尔型索引类似，花式索引是可以使用整数数组进行索引，可以选取任意的行，跟布尔型索引的[True, False , False]类似，可以任意选取。花式索引更方便些。

注意：花式索引是传入整数数组。若为负数，将从末尾开始选取

数组的运算

例3-29

In [27]:

a = [1,2,3]

b = []

#使用循环实现

for i in a:

    b.append(i * i)

print(b)

#使用列表实现

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

c = wy * 2

print(c)

[1, 4, 9]
[2 4 6]

In [ ]:

数组和标量间的运算，数组之所以很强大是因为不需要通过循环就可以完成批量计算

例3-30，3-31

In [13]:

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

y = np.array([4,5,6])

print('x:',x)

print('y:',y)

print('x + y:',x + y)

print('x - y:',x - y)

print('x * y:',x * y)

print('x ** y 表示x的y次方:',x ** y)

x: [1 2 3]
y: [4 5 6]
x + y: [5 7 9]
x - y: [-3 -3 -3]
x * y: [ 4 10 18]
x ** y 表示x的y次方: [  1  32 729]

ufunc函数全称为通用函数，是一种能够对数组中的所有元素进行操作的函数。对一个数组进行重复运算时，使用ufunc函数比使用math库中的函数效率要高很多。

​

常用的ufunc函数运算有四则运算、比较运算和逻辑运算。

1）四则运算：

      加（+）、减（-）、乘（*）、除（/）、幂（**）。数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。

2）比较运算：

      >、<、==、>=、<=、!=。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。

3）逻辑运算：

      np.any函数表示逻辑“or”，np.all函数表示逻辑“and”, 运算结果返回布尔值。

In [29]:

x = np.array([1,3,6])

y = np.array([2,3,4])

print(x < y)

print(x > y)

print(x == y)

print(x >= y)

print(x != y)

[ True False False]
[False False  True]
[False  True False]
[False  True  True]
[ True False  True]

例3-32

In [32]:

arr1 = np.array([[0,0,0],[1,1,1,],[2,2,2]])

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

print(arr1)

print(arr2)

print(arr1 + arr2)#两者维度不匹配就直接扩展arr2

[[0 0 0]
 [1 1 1]
 [2 2 2]]
[1 2 3]
[[1 2 3]
 [2 3 4]
 [3 4 5]]

ufunc函数的广播机制

广播（broadcasting）是指不同形状的数组之间执行算术运算的方式。需要遵循4个原则：

1）让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在左边加1补齐。

2）如果两个数组的形状在任何一个维度上都不匹配，那么数组的形状会沿着维度为1的维度进行扩展，以匹配另一个数组的形状。

3）输出数组的shape是输入数组shape的各个轴上的最大值。

4）如果两个数组的形状在任何一个维度上都不匹配，并且没有任何一个维度等于1，则引发异常

例3-33——3-35

In [33]:

arr1 = np.array([1,3,5,7])

arr2 = np.array([2,4,6,8])

cond = np.array([True,False,True,False])

result = [(x if c else y)for x,y,c in zip(arr1,arr2,cond)]#条件逻辑运算，适用与一维数组

result

Out[33]:

[1, 4, 5, 8]

条件逻辑运算

在NumPy中可以利用基本的逻辑运算就可以实现数组的条件运算。

这种方法对大规模数组处理效率不高，也无法用于多维数组。NumPy提供的where方法可以克服这些问题。

where的用法：np.where(condition, x, y)满足条件(condition)，输出x，不满足则输出y

zip () 函数是 Python 内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range () 区间构成的列表）“压缩”成一个 zip 对象。

总结：zip类似于迭代器

In [36]:

np.where([[True,False],[True,True]],[[1,2],[3,4]],[[9,8],[7,6]])

Out[36]:

array([[1, 8],
       [3, 4]])

条件为[[True,False], [True,False]]，分别对应最后输出结果的四个值，运算时第一个值从[1,9]中选，因为条件为True，所以是选1。第二个值从[2,8]中选，因为条件为False，所以选8，后面以此类推。

where中只有condition参数

where中若只有条件 (condition)，没有x和y，则输出满足条件元素的坐标。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。 

In [37]:

w = np.array([2,5,6,3,10])

np.where(w > 4)#给出对应的位置坐标

Out[37]:

(array([1, 2, 4], dtype=int64),)

例3-36

In [42]:

#数组的读写

a = np.arange(1,13).reshape(3,4)

print(a)

np.save("arr.npy",a)#保存文件"" 与''都可以 用save写入的文件只能用numpy读出，有局限性

c = np.load('arr.npy')#读取文件

print(c)

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

NumPy提供了多种文件操作函数存取数组内容。【也具有一定的局限性】

文件存取的格式分为两类：二进制和文本。而二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。

NumPy中读写二进制文件的方法有：

1. np.load(“文件名.npy")是从二进制文件中读取数据；

2. np.save(“文件名[.npy]", arr) 是以二进制格式保存数据

例3-37

In [20]:

#多个数组的保存

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

b = np.arange(0,1.0,0.1)

print(b)

c = np.sin(b)#长度为10

print(c)

​

#第一种情况：对三个数组并未命名的情况

#np.savez('result.npz',a,b,c)#压缩存储，默认的是arr_0,arr_1,arr_2

#r = np.load('result.npz')#进行读取

#r['arr_0']#查看a数组的内容

#r['arr_1']#查看b数组的内容

#r['arr_2']#查看c数组的内容

​

#第二种情况：对其中的一个数组命名

np.savez('result.npz',a,b,str_arr=c)#savez可以对多个数据进行保存

r = np.load('result.npz')#进行读取

r['str_arr']#若是对其命名，此处必须是命名的数组名称

[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
[0.         0.09983342 0.19866933 0.29552021 0.38941834 0.47942554
 0.56464247 0.64421769 0.71735609 0.78332691]

Out[20]:

array([0.        , 0.09983342, 0.19866933, 0.29552021, 0.38941834,
       0.47942554, 0.56464247, 0.64421769, 0.71735609, 0.78332691])

numpy.savez(file, *args, **kwds)

以未压缩的.npz 格式将多个数组保存到一个文件中。

提供数组作为关键字参数，以将它们存储在输出文件中的相应名称下：savez(fn, x=x, y=y)。

如果数组被指定为位置参数，即，savez(fn, x, y)，他们的名字将是arr_0,arr_1， 等等。

参数：

file： 字符串或文件

将保存数据的文件名(字符串)或打开的文件(file-like 对象)。如果文件是一个字符串或一个路径，.npz 扩展名将被附加到文件名(如果它不存在)。

args： 参数，可选

要保存到文件的数组。请使用关键字参数(参见下面的 kwds)为数组分配名称。指定为 args 的数组将命名为 “arr_0”、“arr_1” 等。

kwds： 关键字参数，可选

要保存到文件的数组。每个数组都将以其对应的关键字名称保存到输出文件中。

返回：None

注意：

.npz 文件格式是文件的压缩存档，以它们包含的变量命名。存档未压缩，存档中的每个文件都包含一个.npy 格式的变量。有关 .npy 格式的说明，请参阅 numpy.lib.format 。

打开保存的时候.npz文件与numpy.load a NpzFile返回对象。这是一个 dictionary-like 对象，可以查询它的数组列表(使用.files属性)，以及数组本身。

传入的 key 千瓦时用作 ZIP 存档中的文件名。因此， key 应该是有效的文件名；例如，避免以/或包含..

使用关键字参数命名变量时，不能命名变量 file ，因为这会导致 file 参数在调用 savez 时被定义两次

例3-38

In [22]:

a = np.arange(0,12,0.5).reshape(4,-1)

print(a)

np.savetxt('a1-out.txt',a)#写入到对应的文件里面

np.loadtxt('a1-out.txt')#将写入的导入到对应的文件当中，调入内存

​

np.savetxt('a2-out.txt',a,fmt = '%d',delimiter = ',')#将a的内容存入到a2-out文件里面，用分隔符隔开

np.loadtxt('a2-out.txt',delimiter = ',')

​

np.savetxt('a3-out.txt',a,fmt = '%.2f',delimiter = ',')#按照逗号分割

np.loadtxt('a3-out.txt',delimiter = ',')

[[ 0.   0.5  1.   1.5  2.   2.5]
 [ 3.   3.5  4.   4.5  5.   5.5]
 [ 6.   6.5  7.   7.5  8.   8.5]
 [ 9.   9.5 10.  10.5 11.  11.5]]

Out[22]:

array([[ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5],
       [ 3. ,  3.5,  4. ,  4.5,  5. ,  5.5],
       [ 6. ,  6.5,  7. ,  7.5,  8. ,  8.5],
       [ 9. ,  9.5, 10. , 10.5, 11. , 11.5]])

NumPy中读写文本文件的主要方法有：

1. np.loadtxt("../tmp/arr.txt",delimiter = ",")把文件加载到一个二维数组中；

2. np.savetxt("../tmp/arr.txt", arr, fmt = "%d", delimiter = ",")是将数组写到某种分隔符隔开的文本文件中；

unpack——如果为true,读入属性将分别写入不同的变量

3. np.genfromtxt("../tmp/arr.txt", delimiter = ",")是结构化数组和缺失数据。

fmt——写入文件的格式%d、%.2f、%.18e

delimter——分割字符串，默认是任何空格

例3-39——3-42

In [53]:

arr = np.array([7,9,5,2,9,4,3,1,4,3])#一维数组

print(arr)

arr.sort()

print(arr)

[7 9 5 2 9 4 3 1 4 3]
[1 2 3 3 4 4 5 7 9 9]

Sort函数对数据直接进行排序，调用改变原始数组，无返回值。

格式：numpy.sort(a, axis, kind, order) 

a——要排序的数组

axis——使得sort函数可以沿着指定轴对数据集进行排序。axis=1为沿横轴排序；axis=0为沿纵轴排序；axis=None,将数组平坦化之后进行排序

kind——排序算法，默认为“quicksort”

order——排序的字段名，可指定字段排序，默认为None

In [54]:

arr = np.array([[4,2,9,5],[6,4,8,3],[1,6,2,4]])#二维数组

print(arr)

arr.sort(axis = 0)#对纵轴排序

arr.sort(axis = 1)#对横轴排序

print(arr)

[[4 2 9 5]
 [6 4 8 3]
 [1 6 2 4]]
[[1 2 2 3]
 [4 4 8 4]
 [6 6 9 5]]

In [2]:

arr = np.array([7,9,5,2,9,4,3,1,4,3])

print(arr)

print(arr.argsort())#返回值为数组排序后的下标排列【间接排序】

print(arr[arr.argsort()])

print(arr[arr.argsort()][-5:])#-5开始到最后，【取的是从最后一位（9）的下标-1开始到-5】排完序之后取其负的值

[7 9 5 2 9 4 3 1 4 3]
[7 3 6 9 5 8 2 0 1 4]
[1 2 3 3 4 4 5 7 9 9]
[4 5 7 9 9]

np.argsort函数和np.lexsort函数根据一个或多个键值对数据集进行排序。

np.argsort():  返回的是数组值从小到大的索引值;      

np.lexsort():  返回值是按照最后一个传入数据排序的结果。

​

使用argsort和lexsort函数，可以在给定一个或多个键时，得到一个由整数构成的索引数组，索引值表示数据在新的序列中的位置。

In [4]:

a = np.array([7,2,1,4])

b = np.array([5,2,6,7])

c = np.array([5,2,4,6])

d = np.lexsort((a,b,c))#优先以c为主

print('排序后：',list(zip(a[d],b[d],c[d])))

排序后： [(2, 2, 2), (1, 6, 4), (7, 5, 5), (4, 7, 6)]

例3-43——3-45

In [62]:

names = np.array(['红色','蓝色','蓝色','白色','红色','红色'])

print(names)

print(np.unique(names))#去重

print(np.unique(names,return_counts = True))#当return_counts = True时可以返回每个取值出现的次数

#>表示大端字节顺序，而<表示小端字节编码.类型说明符(以上情况为i4)可以采用不同的形式：

#b1，i1，i2，i4，i8，u1，u2，u4，u8，f2，f4，f8，c8，c16，a

#(表示字节，整数，无符号整数，浮点数，指定字节长度的复数和固定长度字符串)

#int8，…，uint8，…，float16，float32，float64，complex64，complex128

['红色' '蓝色' '蓝色' '白色' '红色' '红色']
['白色' '红色' '蓝色']
(array(['白色', '红色', '蓝色'], dtype='<U2'), array([1, 3, 2], dtype=int64))

大端模式（big endian）：低位（字节/比特）放在高地址中，高位（字节/比特）放在低地址中。 小端模式（little endian）：低位（字节/比特）放在低地址中，高位（字节/比特）放在高地址中。 在串口等串行通信中，一次只能发1个字节。这个时候遇到一个问题。int类型有4个字节。我们是按照什么顺序发送字节呢。发送方和接收方必须按照同样的字节顺序来通信。这就是通信系统中的大小端模式。 现在我们讲的大小端模式讲的更多的是计算机存储系统的大小端。在计算机内存/硬盘/Nnad中.因为存储系统是32位的,但数据仍然按照字节为单位,于是一个32位的二进制在内存中存储时有两种分布方式。 高位低位，高地址低地址。 高位对应高地址：大端存储模式。 高位对低地址：小端存储模式。 大端模式和小端模式本身没有好坏。但必须要求存储和读取时按照同样的大小端模式，否则会出错。 现实是有些cpu公司用大端（c51），有些用小端（arm、intal）。大部分用小端，大端模式的不是很多。

所谓的大端模式，是指数据的低位（就是权值较小的后面那几位）保存在内存的高地址中，而数据的高位，保存在内存的低地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放； 所谓的小端模式，是指数据的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。

U2： < 代表 byteorder 字节序， 小端字节序 (little-endian) U 代表 Unicode String 2,3等数字， 代表它的存储占用的字节数 bytes

在NumPy中，对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由大到小返回一个新的元组或者列表。

In [5]:

arr = np.arange(5)

print('原数组',arr)

wy = np.tile(arr,3)#重复原始数据，次数为3

print('重复数据处理:\n',wy)

原数组 [0 1 2 3 4]
重复数据处理:
 [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]

统计分析中有时也需要把一个数据重复若干次，使用tile和repeat函数即可实现此功能。

tile函数的格式：np.tile(A, reps)其中，参数A表示要重复的数组，reps表示重复次数。

repeat函数的格式：np.repeat(A, reps, axis = None)

“a”: 是需要重复的数组元素，

“repeats”: 是重复次数，

“axis”: 指定沿着哪个轴进行重复，axis = 0表示按行进行元素重复；axis = 1表示按列进行元素重复。

In [65]:

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

print(arr2)

print(arr2.repeat(2,axis = 1))#重复2次，axis = 1是指在列的方向重复，为0则在行的方向重复

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

例3-46

In [21]:

arr = np.arange(20).reshape(4,5)

print('创建的数组：\n',arr)

print('数组的和：',np.sum(arr))

print('数组纵轴的和：',np.sum(arr,axis = 0))

print('数组横轴的和：',np.sum(arr,axis = 1))

print('数组的均值：',np.mean(arr))

print('数组横轴的均值：',np.mean(arr,axis = 1))

print('数组的标准差：',np.std(arr))

print('数组横轴的标准差：',np.std(arr,axis = 1))

创建的数组：
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
数组的和： 190
数组纵轴的和： [30 34 38 42 46]
数组横轴的和： [10 35 60 85]
数组的均值： 9.5
数组横轴的均值： [ 2.  7. 12. 17.]
数组的标准差： 5.766281297335398
数组横轴的标准差： [1.41421356 1.41421356 1.41421356 1.41421356]

NumPy中提供了很多用于统计分析的函数，常见的有sum、mean、std、var、min和max等。

几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。

axis=0时表示沿着纵轴进行计算，axis=1时沿横轴进行计算。

练习

In [71]:

a = np.arange(8).reshape(2,4)

print(a)

print(np.hsplit(a,2))

[[0 1 2 3]
 [4 5 6 7]]
[array([[0, 1],
       [4, 5]]), array([[2, 3],
       [6, 7]])]

In [72]:

str = np.ones([10,10])

print(str)

str[1:-1,1:-1] = 0

print(str)

[[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. 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.]
 [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. 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.]]
[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]

实训题

读取csv文件【文件更多样】——用来批量处理文件 np.loadtxt(fname, dtype=, comments=’#’, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=‘bytes’) fname——str，读取的CSV文件名 delimiter——str，数据的分割符 usecols——tuple(元组) ，执行加载数据文件中的哪些列 unpack——bool，是否将加载的数据拆分为多个组，True表示拆，False不拆 skipprows——int，跳过多少行，一般用于跳过前几行的描述性文字 encoding——bytes，编码格式

In [6]:

import numpy as np

import csv

In [3]:

iris_data = []

with open("iris.csv") as csvfile:

    csv_reader = csv.reader(csvfile)

    birth_header = next(csv_reader)

    #print(birth_header)

    for row in csv_reader:

        iris_data.append(row)

iris_data

Out[3]:

[['1', '5.1', '3.5', '1.4', '0.2', 'setosa'],
 ['2', '4.9', '3', '1.4', '0.2', 'setosa'],
 ['3', '4.7', '3.2', '1.3', '0.2', 'setosa'],
 ['4', '4.6', '3.1', '1.5', '0.2', 'setosa'],
 ['5', '5', '3.6', '1.4', '0.2', 'setosa'],
 ['6', '5.4', '3.9', '1.7', '0.4', 'setosa'],
 ['7', '4.6', '3.4', '1.4', '0.3', 'setosa'],
 ['8', '5', '3.4', '1.5', '0.2', 'setosa'],
 ['9', '4.4', '2.9', '1.4', '0.2', 'setosa'],
 ['10', '4.9', '3.1', '1.5', '0.1', 'setosa'],
 ['11', '5.4', '3.7', '1.5', '0.2', 'setosa'],
 ['12', '4.8', '3.4', '1.6', '0.2', 'setosa'],
 ['13', '4.8', '3', '1.4', '0.1', 'setosa'],
 ['14', '4.3', '3', '1.1', '0.1', 'setosa'],
 ['15', '5.8', '4', '1.2', '0.2', 'setosa'],
 ['16', '5.7', '4.4', '1.5', '0.4', 'setosa'],
 ['17', '5.4', '3.9', '1.3', '0.4', 'setosa'],
 ['18', '5.1', '3.5', '1.4', '0.3', 'setosa'],
 ['19', '5.7', '3.8', '1.7', '0.3', 'setosa'],
 ['20', '5.1', '3.8', '1.5', '0.3', 'setosa'],
 ['21', '5.4', '3.4', '1.7', '0.2', 'setosa'],
 ['22', '5.1', '3.7', '1.5', '0.4', 'setosa'],
 ['23', '4.6', '3.6', '1', '0.2', 'setosa'],
 ['24', '5.1', '3.3', '1.7', '0.5', 'setosa'],
 ['25', '4.8', '3.4', '1.9', '0.2', 'setosa'],
 ['26', '5', '3', '1.6', '0.2', 'setosa'],
 ['27', '5', '3.4', '1.6', '0.4', 'setosa'],
 ['28', '5.2', '3.5', '1.5', '0.2', 'setosa'],
 ['29', '5.2', '3.4', '1.4', '0.2', 'setosa'],
 ['30', '4.7', '3.2', '1.6', '0.2', 'setosa'],
 ['31', '4.8', '3.1', '1.6', '0.2', 'setosa'],
 ['32', '5.4', '3.4', '1.5', '0.4', 'setosa'],
 ['33', '5.2', '4.1', '1.5', '0.1', 'setosa'],
 ['34', '5.5', '4.2', '1.4', '0.2', 'setosa'],
 ['35', '4.9', '3.1', '1.5', '0.2', 'setosa'],
 ['36', '5', '3.2', '1.2', '0.2', 'setosa'],
 ['37', '5.5', '3.5', '1.3', '0.2', 'setosa'],
 ['38', '4.9', '3.6', '1.4', '0.1', 'setosa'],
 ['39', '4.4', '3', '1.3', '0.2', 'setosa'],
 ['40', '5.1', '3.4', '1.5', '0.2', 'setosa'],
 ['41', '5', '3.5', '1.3', '0.3', 'setosa'],
 ['42', '4.5', '2.3', '1.3', '0.3', 'setosa'],
 ['43', '4.4', '3.2', '1.3', '0.2', 'setosa'],
 ['44', '5', '3.5', '1.6', '0.6', 'setosa'],
 ['45', '5.1', '3.8', '1.9', '0.4', 'setosa'],
 ['46', '4.8', '3', '1.4', '0.3', 'setosa'],
 ['47', '5.1', '3.8', '1.6', '0.2', 'setosa'],
 ['48', '4.6', '3.2', '1.4', '0.2', 'setosa'],
 ['49', '5.3', '3.7', '1.5', '0.2', 'setosa'],
 ['50', '5', '3.3', '1.4', '0.2', 'setosa'],
 ['51', '7', '3.2', '4.7', '1.4', 'versicolor'],
 ['52', '6.4', '3.2', '4.5', '1.5', 'versicolor'],
 ['53', '6.9', '3.1', '4.9', '1.5', 'versicolor'],
 ['54', '5.5', '2.3', '4', '1.3', 'versicolor'],
 ['55', '6.5', '2.8', '4.6', '1.5', 'versicolor'],
 ['56', '5.7', '2.8', '4.5', '1.3', 'versicolor'],
 ['57', '6.3', '3.3', '4.7', '1.6', 'versicolor'],
 ['58', '4.9', '2.4', '3.3', '1', 'versicolor'],
 ['59', '6.6', '2.9', '4.6', '1.3', 'versicolor'],
 ['60', '5.2', '2.7', '3.9', '1.4', 'versicolor'],
 ['61', '5', '2', '3.5', '1', 'versicolor'],
 ['62', '5.9', '3', '4.2', '1.5', 'versicolor'],
 ['63', '6', '2.2', '4', '1', 'versicolor'],
 ['64', '6.1', '2.9', '4.7', '1.4', 'versicolor'],
 ['65', '5.6', '2.9', '3.6', '1.3', 'versicolor'],
 ['66', '6.7', '3.1', '4.4', '1.4', 'versicolor'],
 ['67', '5.6', '3', '4.5', '1.5', 'versicolor'],
 ['68', '5.8', '2.7', '4.1', '1', 'versicolor'],
 ['69', '6.2', '2.2', '4.5', '1.5', 'versicolor'],
 ['70', '5.6', '2.5', '3.9', '1.1', 'versicolor'],
 ['71', '5.9', '3.2', '4.8', '1.8', 'versicolor'],
 ['72', '6.1', '2.8', '4', '1.3', 'versicolor'],
 ['73', '6.3', '2.5', '4.9', '1.5', 'versicolor'],
 ['74', '6.1', '2.8', '4.7', '1.2', 'versicolor'],
 ['75', '6.4', '2.9', '4.3', '1.3', 'versicolor'],
 ['76', '6.6', '3', '4.4', '1.4', 'versicolor'],
 ['77', '6.8', '2.8', '4.8', '1.4', 'versicolor'],
 ['78', '6.7', '3', '5', '1.7', 'versicolor'],
 ['79', '6', '2.9', '4.5', '1.5', 'versicolor'],
 ['80', '5.7', '2.6', '3.5', '1', 'versicolor'],
 ['81', '5.5', '2.4', '3.8', '1.1', 'versicolor'],
 ['82', '5.5', '2.4', '3.7', '1', 'versicolor'],
 ['83', '5.8', '2.7', '3.9', '1.2', 'versicolor'],
 ['84', '6', '2.7', '5.1', '1.6', 'versicolor'],
 ['85', '5.4', '3', '4.5', '1.5', 'versicolor'],
 ['86', '6', '3.4', '4.5', '1.6', 'versicolor'],
 ['87', '6.7', '3.1', '4.7', '1.5', 'versicolor'],
 ['88', '6.3', '2.3', '4.4', '1.3', 'versicolor'],
 ['89', '5.6', '3', '4.1', '1.3', 'versicolor'],
 ['90', '5.5', '2.5', '4', '1.3', 'versicolor'],
 ['91', '5.5', '2.6', '4.4', '1.2', 'versicolor'],
 ['92', '6.1', '3', '4.6', '1.4', 'versicolor'],
 ['93', '5.8', '2.6', '4', '1.2', 'versicolor'],
 ['94', '5', '2.3', '3.3', '1', 'versicolor'],
 ['95', '5.6', '2.7', '4.2', '1.3', 'versicolor'],
 ['96', '5.7', '3', '4.2', '1.2', 'versicolor'],
 ['97', '5.7', '2.9', '4.2', '1.3', 'versicolor'],
 ['98', '6.2', '2.9', '4.3', '1.3', 'versicolor'],
 ['99', '5.1', '2.5', '3', '1.1', 'versicolor'],
 ['100', '5.7', '2.8', '4.1', '1.3', 'versicolor'],
 ['101', '6.3', '3.3', '6', '2.5', 'virginica'],
 ['102', '5.8', '2.7', '5.1', '1.9', 'virginica'],
 ['103', '7.1', '3', '5.9', '2.1', 'virginica'],
 ['104', '6.3', '2.9', '5.6', '1.8', 'virginica'],
 ['105', '6.5', '3', '5.8', '2.2', 'virginica'],
 ['106', '7.6', '3', '6.6', '2.1', 'virginica'],
 ['107', '4.9', '2.5', '4.5', '1.7', 'virginica'],
 ['108', '7.3', '2.9', '6.3', '1.8', 'virginica'],
 ['109', '6.7', '2.5', '5.8', '1.8', 'virginica'],
 ['110', '7.2', '3.6', '6.1', '2.5', 'virginica'],
 ['111', '6.5', '3.2', '5.1', '2', 'virginica'],
 ['112', '6.4', '2.7', '5.3', '1.9', 'virginica'],
 ['113', '6.8', '3', '5.5', '2.1', 'virginica'],
 ['114', '5.7', '2.5', '5', '2', 'virginica'],
 ['115', '5.8', '2.8', '5.1', '2.4', 'virginica'],
 ['116', '6.4', '3.2', '5.3', '2.3', 'virginica'],
 ['117', '6.5', '3', '5.5', '1.8', 'virginica'],
 ['118', '7.7', '3.8', '6.7', '2.2', 'virginica'],
 ['119', '7.7', '2.6', '6.9', '2.3', 'virginica'],
 ['120', '6', '2.2', '5', '1.5', 'virginica'],
 ['121', '6.9', '3.2', '5.7', '2.3', 'virginica'],
 ['122', '5.6', '2.8', '4.9', '2', 'virginica'],
 ['123', '7.7', '2.8', '6.7', '2', 'virginica'],
 ['124', '6.3', '2.7', '4.9', '1.8', 'virginica'],
 ['125', '6.7', '3.3', '5.7', '2.1', 'virginica'],
 ['126', '7.2', '3.2', '6', '1.8', 'virginica'],
 ['127', '6.2', '2.8', '4.8', '1.8', 'virginica'],
 ['128', '6.1', '3', '4.9', '1.8', 'virginica'],
 ['129', '6.4', '2.8', '5.6', '2.1', 'virginica'],
 ['130', '7.2', '3', '5.8', '1.6', 'virginica'],
 ['131', '7.4', '2.8', '6.1', '1.9', 'virginica'],
 ['132', '7.9', '3.8', '6.4', '2', 'virginica'],
 ['133', '6.4', '2.8', '5.6', '2.2', 'virginica'],
 ['134', '6.3', '2.8', '5.1', '1.5', 'virginica'],
 ['135', '6.1', '2.6', '5.6', '1.4', 'virginica'],
 ['136', '7.7', '3', '6.1', '2.3', 'virginica'],
 ['137', '6.3', '3.4', '5.6', '2.4', 'virginica'],
 ['138', '6.4', '3.1', '5.5', '1.8', 'virginica'],
 ['139', '6', '3', '4.8', '1.8', 'virginica'],
 ['140', '6.9', '3.1', '5.4', '2.1', 'virginica'],
 ['141', '6.7', '3.1', '5.6', '2.4', 'virginica'],
 ['142', '6.9', '3.1', '5.1', '2.3', 'virginica'],
 ['143', '5.8', '2.7', '5.1', '1.9', 'virginica'],
 ['144', '6.8', '3.2', '5.9', '2.3', 'virginica'],
 ['145', '6.7', '3.3', '5.7', '2.5', 'virginica'],
 ['146', '6.7', '3', '5.2', '2.3', 'virginica'],
 ['147', '6.3', '2.5', '5', '1.9', 'virginica'],
 ['148', '6.5', '3', '5.2', '2', 'virginica'],
 ['149', '6.2', '3.4', '5.4', '2.3', 'virginica'],
 ['150', '5.9', '3', '5.1', '1.8', 'virginica']]

In [76]:

iris_list = []

for row in iris_data:

    iris_list.append(tuple(row[1:]))

iris_list

Out[76]:

[('5.1', '3.5', '1.4', '0.2', 'setosa'),
 ('4.9', '3', '1.4', '0.2', 'setosa'),
 ('4.7', '3.2', '1.3', '0.2', 'setosa'),
 ('4.6', '3.1', '1.5', '0.2', 'setosa'),
 ('5', '3.6', '1.4', '0.2', 'setosa'),
 ('5.4', '3.9', '1.7', '0.4', 'setosa'),
 ('4.6', '3.4', '1.4', '0.3', 'setosa'),
 ('5', '3.4', '1.5', '0.2', 'setosa'),
 ('4.4', '2.9', '1.4', '0.2', 'setosa'),
 ('4.9', '3.1', '1.5', '0.1', 'setosa'),
 ('5.4', '3.7', '1.5', '0.2', 'setosa'),
 ('4.8', '3.4', '1.6', '0.2', 'setosa'),
 ('4.8', '3', '1.4', '0.1', 'setosa'),
 ('4.3', '3', '1.1', '0.1', 'setosa'),
 ('5.8', '4', '1.2', '0.2', 'setosa'),
 ('5.7', '4.4', '1.5', '0.4', 'setosa'),
 ('5.4', '3.9', '1.3', '0.4', 'setosa'),
 ('5.1', '3.5', '1.4', '0.3', 'setosa'),
 ('5.7', '3.8', '1.7', '0.3', 'setosa'),
 ('5.1', '3.8', '1.5', '0.3', 'setosa'),
 ('5.4', '3.4', '1.7', '0.2', 'setosa'),
 ('5.1', '3.7', '1.5', '0.4', 'setosa'),
 ('4.6', '3.6', '1', '0.2', 'setosa'),
 ('5.1', '3.3', '1.7', '0.5', 'setosa'),
 ('4.8', '3.4', '1.9', '0.2', 'setosa'),
 ('5', '3', '1.6', '0.2', 'setosa'),
 ('5', '3.4', '1.6', '0.4', 'setosa'),
 ('5.2', '3.5', '1.5', '0.2', 'setosa'),
 ('5.2', '3.4', '1.4', '0.2', 'setosa'),
 ('4.7', '3.2', '1.6', '0.2', 'setosa'),
 ('4.8', '3.1', '1.6', '0.2', 'setosa'),
 ('5.4', '3.4', '1.5', '0.4', 'setosa'),
 ('5.2', '4.1', '1.5', '0.1', 'setosa'),
 ('5.5', '4.2', '1.4', '0.2', 'setosa'),
 ('4.9', '3.1', '1.5', '0.2', 'setosa'),
 ('5', '3.2', '1.2', '0.2', 'setosa'),
 ('5.5', '3.5', '1.3', '0.2', 'setosa'),
 ('4.9', '3.6', '1.4', '0.1', 'setosa'),
 ('4.4', '3', '1.3', '0.2', 'setosa'),
 ('5.1', '3.4', '1.5', '0.2', 'setosa'),
 ('5', '3.5', '1.3', '0.3', 'setosa'),
 ('4.5', '2.3', '1.3', '0.3', 'setosa'),
 ('4.4', '3.2', '1.3', '0.2', 'setosa'),
 ('5', '3.5', '1.6', '0.6', 'setosa'),
 ('5.1', '3.8', '1.9', '0.4', 'setosa'),
 ('4.8', '3', '1.4', '0.3', 'setosa'),
 ('5.1', '3.8', '1.6', '0.2', 'setosa'),
 ('4.6', '3.2', '1.4', '0.2', 'setosa'),
 ('5.3', '3.7', '1.5', '0.2', 'setosa'),
 ('5', '3.3', '1.4', '0.2', 'setosa'),
 ('7', '3.2', '4.7', '1.4', 'versicolor'),
 ('6.4', '3.2', '4.5', '1.5', 'versicolor'),
 ('6.9', '3.1', '4.9', '1.5', 'versicolor'),
 ('5.5', '2.3', '4', '1.3', 'versicolor'),
 ('6.5', '2.8', '4.6', '1.5', 'versicolor'),
 ('5.7', '2.8', '4.5', '1.3', 'versicolor'),
 ('6.3', '3.3', '4.7', '1.6', 'versicolor'),
 ('4.9', '2.4', '3.3', '1', 'versicolor'),
 ('6.6', '2.9', '4.6', '1.3', 'versicolor'),
 ('5.2', '2.7', '3.9', '1.4', 'versicolor'),
 ('5', '2', '3.5', '1', 'versicolor'),
 ('5.9', '3', '4.2', '1.5', 'versicolor'),
 ('6', '2.2', '4', '1', 'versicolor'),
 ('6.1', '2.9', '4.7', '1.4', 'versicolor'),
 ('5.6', '2.9', '3.6', '1.3', 'versicolor'),
 ('6.7', '3.1', '4.4', '1.4', 'versicolor'),
 ('5.6', '3', '4.5', '1.5', 'versicolor'),
 ('5.8', '2.7', '4.1', '1', 'versicolor'),
 ('6.2', '2.2', '4.5', '1.5', 'versicolor'),
 ('5.6', '2.5', '3.9', '1.1', 'versicolor'),
 ('5.9', '3.2', '4.8', '1.8', 'versicolor'),
 ('6.1', '2.8', '4', '1.3', 'versicolor'),
 ('6.3', '2.5', '4.9', '1.5', 'versicolor'),
 ('6.1', '2.8', '4.7', '1.2', 'versicolor'),
 ('6.4', '2.9', '4.3', '1.3', 'versicolor'),
 ('6.6', '3', '4.4', '1.4', 'versicolor'),
 ('6.8', '2.8', '4.8', '1.4', 'versicolor'),
 ('6.7', '3', '5', '1.7', 'versicolor'),
 ('6', '2.9', '4.5', '1.5', 'versicolor'),
 ('5.7', '2.6', '3.5', '1', 'versicolor'),
 ('5.5', '2.4', '3.8', '1.1', 'versicolor'),
 ('5.5', '2.4', '3.7', '1', 'versicolor'),
 ('5.8', '2.7', '3.9', '1.2', 'versicolor'),
 ('6', '2.7', '5.1', '1.6', 'versicolor'),
 ('5.4', '3', '4.5', '1.5', 'versicolor'),
 ('6', '3.4', '4.5', '1.6', 'versicolor'),
 ('6.7', '3.1', '4.7', '1.5', 'versicolor'),
 ('6.3', '2.3', '4.4', '1.3', 'versicolor'),
 ('5.6', '3', '4.1', '1.3', 'versicolor'),
 ('5.5', '2.5', '4', '1.3', 'versicolor'),
 ('5.5', '2.6', '4.4', '1.2', 'versicolor'),
 ('6.1', '3', '4.6', '1.4', 'versicolor'),
 ('5.8', '2.6', '4', '1.2', 'versicolor'),
 ('5', '2.3', '3.3', '1', 'versicolor'),
 ('5.6', '2.7', '4.2', '1.3', 'versicolor'),
 ('5.7', '3', '4.2', '1.2', 'versicolor'),
 ('5.7', '2.9', '4.2', '1.3', 'versicolor'),
 ('6.2', '2.9', '4.3', '1.3', 'versicolor'),
 ('5.1', '2.5', '3', '1.1', 'versicolor'),
 ('5.7', '2.8', '4.1', '1.3', 'versicolor'),
 ('6.3', '3.3', '6', '2.5', 'virginica'),
 ('5.8', '2.7', '5.1', '1.9', 'virginica'),
 ('7.1', '3', '5.9', '2.1', 'virginica'),
 ('6.3', '2.9', '5.6', '1.8', 'virginica'),
 ('6.5', '3', '5.8', '2.2', 'virginica'),
 ('7.6', '3', '6.6', '2.1', 'virginica'),
 ('4.9', '2.5', '4.5', '1.7', 'virginica'),
 ('7.3', '2.9', '6.3', '1.8', 'virginica'),
 ('6.7', '2.5', '5.8', '1.8', 'virginica'),
 ('7.2', '3.6', '6.1', '2.5', 'virginica'),
 ('6.5', '3.2', '5.1', '2', 'virginica'),
 ('6.4', '2.7', '5.3', '1.9', 'virginica'),
 ('6.8', '3', '5.5', '2.1', 'virginica'),
 ('5.7', '2.5', '5', '2', 'virginica'),
 ('5.8', '2.8', '5.1', '2.4', 'virginica'),
 ('6.4', '3.2', '5.3', '2.3', 'virginica'),
 ('6.5', '3', '5.5', '1.8', 'virginica'),
 ('7.7', '3.8', '6.7', '2.2', 'virginica'),
 ('7.7', '2.6', '6.9', '2.3', 'virginica'),
 ('6', '2.2', '5', '1.5', 'virginica'),
 ('6.9', '3.2', '5.7', '2.3', 'virginica'),
 ('5.6', '2.8', '4.9', '2', 'virginica'),
 ('7.7', '2.8', '6.7', '2', 'virginica'),
 ('6.3', '2.7', '4.9', '1.8', 'virginica'),
 ('6.7', '3.3', '5.7', '2.1', 'virginica'),
 ('7.2', '3.2', '6', '1.8', 'virginica'),
 ('6.2', '2.8', '4.8', '1.8', 'virginica'),
 ('6.1', '3', '4.9', '1.8', 'virginica'),
 ('6.4', '2.8', '5.6', '2.1', 'virginica'),
 ('7.2', '3', '5.8', '1.6', 'virginica'),
 ('7.4', '2.8', '6.1', '1.9', 'virginica'),
 ('7.9', '3.8', '6.4', '2', 'virginica'),
 ('6.4', '2.8', '5.6', '2.2', 'virginica'),
 ('6.3', '2.8', '5.1', '1.5', 'virginica'),
 ('6.1', '2.6', '5.6', '1.4', 'virginica'),
 ('7.7', '3', '6.1', '2.3', 'virginica'),
 ('6.3', '3.4', '5.6', '2.4', 'virginica'),
 ('6.4', '3.1', '5.5', '1.8', 'virginica'),
 ('6', '3', '4.8', '1.8', 'virginica'),
 ('6.9', '3.1', '5.4', '2.1', 'virginica'),
 ('6.7', '3.1', '5.6', '2.4', 'virginica'),
 ('6.9', '3.1', '5.1', '2.3', 'virginica'),
 ('5.8', '2.7', '5.1', '1.9', 'virginica'),
 ('6.8', '3.2', '5.9', '2.3', 'virginica'),
 ('6.7', '3.3', '5.7', '2.5', 'virginica'),
 ('6.7', '3', '5.2', '2.3', 'virginica'),
 ('6.3', '2.5', '5', '1.9', 'virginica'),
 ('6.5', '3', '5.2', '2', 'virginica'),
 ('6.2', '3.4', '5.4', '2.3', 'virginica'),
 ('5.9', '3', '5.1', '1.8', 'virginica')]

In [ ]:

datatype = np.dtype([('S')])