Python学习之高级数组（一）

1.python基础学习之高级数组（一）

1.1视图：就是与较大数组共享相同数据的较小数组。numpy包提供数据视图的概念是为了精确地控制内存的使用方式。  数组视图、切片视图、转置和重塑视图等

数组视图实例：

from numpy import*

m=array([[1.,2.],[3.,4.]])

v=m[0,:]    #切片是数组的视图（切片视图），它与m享有相同的数据。

print(v)

v[-1]=0

print(v)

print(m)       #注意：如果修改v，m也会同时被修改

print(v.base)       #数组的属性base能够访问拥有数据的对象，若数组拥有本身的数据，

#则其属性base的值为none

print(v.base is m)

print(m.base)

运行结果：

[1. 2.]

[1. 0.]

[[1. 0.]

 [3. 4.]]

[[1. 0.]

 [3. 4.]]

true

none

切片视图：只有基本切片（主要为带冒号的索引表达式）将返回视图，而任何高级切片（如使用布尔值的切片）都将返回数据的副本。

例如：

a=arange(4)

b=a[[2,3]]      #索引是一个列表[2,3],b是数组

print(b)

print(b.base is none)      #数据被复制，b是数组

c=a[1:3]                

print(c)

print(c.base is none)       

m=m[:]

print(m)

补充：numpy的试图与副本：

 视图：是数据的一个别称或引用，通过该别称或引用亦便访问、操作原有数据，但是原有数据不会产生拷贝。如果对视图进行修改，他就会影响到原有数据（原有数据同时被修改），物理内存在同一位置。

副本: 是对一个数据的完整拷贝，如果对副本进行修改，它不会影响到原有数据，物理地址不存在同一个位置。

具体分为：

①　无复制：简单的复制不会创建数组对象的副本。它使用原始数据的相同id()来访问它。id()返回python对象的通用标识符，类似于c中的指针。

一个数组的任何变化都反映在另一个数组上。例如，一个数组的形状改变另一个数组的形状。

②　视图或者浅复制：numpy拥有ndarray.view()方法，是一个新的数组对象，并且可查看原始数组的相同数据。新数组的维数更改不会更改原始数据的维数。

实例：

from numpy import*                       

a=arange(6).reshape(3,2)

print(a)

b=a.view()

print(b)

c=b.reshape(2,3)

print(c)

print(a.shape)      #注意：数组b（新视图）的维数改变不影响原始数据的维数

print(id(a))

print(id(b))         #两个数组的id不变

运行结果：

[[0 1]

 [2 3]

 [4 5]]

[[0 1]

 [2 3]

 [4 5]]

[[0 1 2]

 [3 4 5]]

(3, 2)

144810752

144810112

③　深复制（副本）：ndarray.copy()函数创建一个深层副本。是数组及其数据的完整副本，不与原始数据共享。

实例：import numpy as np

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

print  ('数组 a：')  

print (a)

print  ('创建 a 的深层副本：' )

b = a.copy()  

print  ('数组 b：' )

print (b)

# b 与 a 不共享任何内容  

print  ('我们能够写入 b 来写入 a 吗？' )

print (b is a )

print  ('修改 b 的内容：')

b[0,0]  =  100  

print  ('修改后的数组 b：')  

print (b)

print  ('a 保持不变：')  

print (a)

运算结果：

数组 a：

[[10 10]

 [ 2  3]

 [ 4  5]]

创建 a 的深层副本：

数组 b：

[[10 10]

 [ 2  3]

 [ 4  5]]

我们能够写入 b 来写入 a 吗？

false

修改 b 的内容：

修改后的数组 b：

[[100  10]

 [  2   3]

 [  4   5]]

a 保持不变：

[[10 10]

 [ 2  3]

 [ 4  5]]

1. 2.数组比较：

  数组比较是为了检查两个矩阵是否彼此接近。

布尔数组：元素是bool类型的数组。任何作用于数组的比较运算都将创建一个布尔数组，而不是布尔值。

例如：m=array([[2.,3.],[1.,4.]])

print(m>2)       #数组的比较运算创建了布尔数组

运行结果为：[[false  true]

               [false  true]]

注意：在条件语句中不能直接使用数组比较，应使用all和any方法。

例：

m=array([[2.,3.],[1.,4.]])

n=array([[1.,2.],[3.,3.]])

print(m==n)     #返回布尔数组

print((m==n).all())

print((m!=n).any())     #返回ture

if (abs(n-m)<1e-10).all():     #abs()函数返回数字的绝对值

print("the two arrays are close enough")        

运行结果：[[false false]

           [false false]]

false

true

相等判断：两个浮点数组的相等判断不是直接进行。在numpy中用allclose（）函数来判断，该函数判断了两个到达精度的数组是否相等。

因为两个浮点数可能无限接近而不相等。

例如：

data=random.rand(2)*1e-3      #random.rand()生成随机数组

small_error=random.rand(2)*1e-16

print(data)

print(small_error)

print(data==data+small_error)

print(allclose(data,data+small_error,rtol=1.e-5,atol=1.e-8))     #其误差是根据相对误差界限#rtol和atol给出的

运行结果：

[2.46971243e-04 6.77622235e-05]

[2.78354596e-17 6.88850359e-17]

[false false]      true

1. 3 数组索引

（1）除去基本的切片技术（见https://www.cnblogs.com/chenzhijuan-324/p/10577513.html）可以通过组合切片和整数来索引数组。这里介绍使用布尔数组根据数组中的元素的值来访问和修改数组的一部分。注意：索引操作的结果总是一个向量。

例如：

b=array([[true,false],[false,true]])

m=array([[2,3],[1,4]])

print(m[b])                   #根据布尔数组进行索引

m[b]=10,20              #用其他值来替代索引所得的值   

print(m)

m[m>2]=0         #m的所有大于2的元素均被0替代

print(m)

运算结果：

[2 4]

[[10  3]

 [ 1 20]]

[[0 0]

 [1 0]]

  （2） where命令：

基本结构：where(condition,a,b)       该结构将布尔数组作为条件，并返回满足条件的数组元组的索引，或者根据布尔数组中的值返回不同的值

例如：

x=linspace(-4,4,5)

print(x)

print(where(x>0,sqrt(x),0))

print(where(x>0,1,-1))     #表示若x>0,返回1，否则返回-1

a=arange(9)

b=a.reshape((3,3))

print(b)

print(where(a>5))     #返回一个元组，这个元组包含了满足条件的元素的索引。

print(where(b>5))   

运行结果：

[-4. -2.  0.  2.  4.]

[0.         0.         0.         1.41421356 2.        ]

[-1 -1 -1  1  1]

[[0 1 2]

 [3 4 5]

 [6 7 8]]

(array([6, 7, 8], dtype=int64),)

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