Numpy库

1、numpy   Ndarray对象

'''
ndarray对象是存放同类型元素的多维数组
ndarray对象每个元素在内存中都有相同存储大小的区域
ndarray 内部由以下内容组成：
   （1） 一个指向数据（内存或内存映射文件中的一块数据）的指针。
   （2） 数据类型或 dtype，描述在数组中的固定大小值的格子。
   （3）一个表示数组形状（shape）的元组，表示各维度大小的元组。
   （4） 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数
'''

2、Ndarray对象属性

'''
(1)ndarray.ndim:数组轴的个数，在python的世界中，轴的个数被称作秩.
(2)ndarray.shape:数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性.
(3)ndarray.size:数组元素的总个数，等于shape属性中元组元素的乘积.
(4)ndarray.dtype:一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型.
(5)ndarray.itemsize:数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8).
(6)ndarray.data:包含实际数组元素的缓冲区，通常我们不需要使用这个属性，因为我们总是通过索引来使用数组中的元素.
'''

#属性使用示例
t = numpy.array([[1,2,3],[4,5,6]])

print(t.ndim)
print(t.shape)
print(t.size)
print(t.dtype)
print(t.itemsize)
print(t.data)

#结果
2
(2, 3)
6
int32
4
<memory at 0x000002917BCE8110>

3、创建数组合集

'''
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
常用参数说明：
object:数组或嵌套的数列
dtype:指定数组元素的数据类型，可选
ndmin:指定生成数组的最小维度
'''

#创建一个维度数组
n1 = array([1,2,3])
print(n1)

#创建两个维度数组
n2 = array([[1,2,3],[4,5,6]])
print(n2)

#指定最小维度数组
n3 = array([1,2,3],ndmin=2)
print(n3)

#指定数据类型
n4 = array([1,2,3],dtype = 'int8')
print(n4)
print(n4.dtype)


'''
函数function创建一个全是0的数组，函数ones创建一个全1的数组，函数empty创建一个内容
随机并且依赖与内存状态的数组。默认创建的数组类型(dtype)都是float64。
'''

#zeros创建全为0数组
n1 = np.zeros((3,4),dtype = 'int8')
print(n1)

#ones创建全为1数组
n2 = np.ones((3,4),dtype = 'int8')
print(n2)

#empty创建随机数组
n3 = np.empty((3,4),dtype = 'float32')
print(n3)

'''
已有数组创建数组
'''
'''
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个.numpy.asarray(a, dtype = None, order = None)
a:任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
'''
n1 = np.asarray([1,2,3,4])
n2 = np.asarray([(1,2),(3,4)])
n3 = np.asarray((1,2,3,4))
n4 = np.asarray(((1,2),(3,4)))
n5 = np.asarray(([1,2],[3,4]))
print(n1)
print(n2)
print(n3)
print(n4)
print(n5)


'''
numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象.
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
numpy.fromfunction
'''
s = b'hello'
n6 = np.frombuffer(s,dtype='S1',count=3,offset=1)
print(n6)

'''
numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组.
numpy.fromiter(iterable, dtype, count=-1)
'''
list=range(5)
it=iter(list)
x=np.fromiter(it, dtype=float)
print(x)

'''
数值范围创建数组
'''
#arange函数:numpy.arange(start, stop, step, dtype)

n1 = np.arange(1,11,dtype = 'int8').reshape(2,5)
print(n1)

#linspace:np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

n2 = np.linspace(1,11,num=10,endpoint=False,retstep=True,dtype='int16')
print(n2)

#logspace:np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

n3 = np.logspace(1,10,num=10,endpoint=True,base=2,dtype='float64')
print(n3)

4、数组数据类型

 该numpy库数据类型引用菜鸟教程的资料：https://www.runoob.com/numpy/numpy-dtype.html

 5、数组切片、索引和迭代

#一维数组可以被索引、切片和迭代，就像列表和其它Python序列。

n = np.arange(1,10,dtype = 'int32')**3
print(n)

#切片
print(n[1],n[6])
#索引
print(n[1:6])
print(n[1:6:2])
print(n[::-1])
#迭代
for i in n:
    print(round(i**(1/3)))


#创建二维数组,并切片、索引和迭代
def f(x,y):
    return 10*x+y

n = np.fromfunction(f,(5,4),dtype='int32')
#索引单个元素
print(n[2,3])
#索引一行
print(n[:,2])
#索引一列
print(n[2,:])
#索引全部
print(n[:,:])
#切片
print(n[1])
#迭代
for row in n:
    for col in row:
        print(col)

#三维数组迭代、切片、索引
n = np.arange(24).reshape(2,3,4)
print(n)
#切片
print(n[1])
#索引
print(n[1,2])
print(n[1,2,2])
print(n[1,0:2,0:3])
#迭代
for i in n:
    print(i)

6、高级索引 

#整数数组索引
n = np.array([[1,2],[3,4],[5,6]])
print(n)
row = [0,1,0]
col = [0,1,1]
print(n[row,col])

#布尔索引
x = np.arange(12).reshape(3,4)
print(x[x>6])

a = np.array([np.nan,2,4,5,np.nan])
print(a[~np.isnan(a)])

#花式索引
b = np.arange(32).reshape(8,4)
print(b)

print(b[[4,2,1,7]])
print(b[[-4,-2,-1,-7]])

print('\n')
print(b[[1,5,7,2],[0,3,2,1]]) #整数索引
print(b[np.ix_([1,5,7,2],[0,3,2,1])])  #花式索引需用np.ix_

7、形状修改

# 数组形状修改

#reshape函数
print(n.reshape(3,4)

#shape属性
n.shape=(3,4)

#ravel函数
n.ravel()
n.ravel(order = 'F')

#flat元素迭代器
for i in n.flat:print(i)

#flatten函数
n.flatten()
n.flatten(order='F')

8、数组翻转

#翻转数组
a = np.arange(12).reshape(3,4)
print(a)
print(a.transpose())
print(a.T)

#numpy.rollaxis 函数向后滚动特定的轴到一个特定位置
b = a.reshape(2,3,2)
print(b)
np.rollaxis(b,1,0) #对换位置

#numpy.swapaxes 函数用于交换数组的两个轴
b = a.reshape(2,3,2)
print(b)
np.swapaxes(b,2,1)

9、数组拼接

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

#numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组
c1 = np.concatenate((a,b),axis=0)
c2 = np.concatenate((a,b),axis=1)
print(c1)
print(c2)

#numpy.stack 函数用于沿新轴连接数组序列
d1 = np.stack((a,b),0)
d2 = np.stack((a,b),1)
print(d1)
print(d2)

#numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组
e = np.hstack((a,b))
print(e)

#numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组
f = np.vstack((a,b))
print(f)

10、数组分割

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

#numpy.split 函数沿特定的轴将数组分割为子数组
b1 = np.split(a,4,0)
b2 = np.split(a,4,1)
print(b1)
print(b2)

#numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组
c = np.hsplit(a,2)
print(c)

#numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同
d = np.vsplit(a,2)
print(d)

11、数组元素增加与删除

#numpy.resize 函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本
n = np.arange(6).reshape(2,3)
n1 = np.resize(a,(3,2))
print(n1)
n2 = np.resize(a,(4,3))
print(n2)

'''
numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，
并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
'''
a = np.array([[1,2],[3,4]])
b = np.append(a,[8,9])
c = np.append(a,[[8,9]],axis = 0)
d = np.append(a,[[1,2],[5,6]],axis = 1)
print(b)
print(c)
print(d)

'''
numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。如果值的类型转换为要插入，则它
与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开
'''
a = np.array([[1,2],[3,4],[5,6]])
b = np.insert(a,5,[10])
print(b)
c = np.insert(a,2,[10],0)
print(c)
d = np.insert(a,2,11,1)
print(d)

#numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开
a = np.array([[1,2],[3,4],[5,6]])
b = np.delete(a,5)
print(b)
c = np.delete(a,1,0)
print(c)
d = np.delete(a,1,1)
print(d)

#numpy.unique 函数用于去除数组中的重复元素
a = np.array([5,2,6,2,7,5,6,8,2,9])
u = np.unique(a)
print(u)

b,c = np.unique(a,return_index=True)
print(b)
print(c)
d,e = np.unique(a,return_inverse=True)
print(d)
print(e)

f,g = np.unique(a,return_counts=True)
print(f)
print(g)

12、位运算

#位运算
a = np.array([[1,2],[10,12]])
b = np.array([[4,7],[30,21]])

print(np.bitwise_and(a,b))  #位与运算
print(np.bitwise_or(a,b))   #位或运算
print(np.invert(a))         #取反运算
print(np.left_shift(a,1))   #左移
print(np.right_shift(a,1))  #右移

13、字符串函数

a = np.array([['tan'],['yang']])
b = np.array([['tan'],['mei']])

#numpy.char.add() 函数依次对两个数组的元素进行字符串连接
c = np.char.add(a,b)
print(c)

#numpy.char.multiply() 函数执行多重连接。
d = np.char.multiply(a,3)
print(d)

#numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。
e = np.char.center(a,20,fillchar='*')
print(e)

#numpy.char.capitalize() 函数将字符串的第一个字母转换为大写
f = np.char.capitalize(a)
print(f)

#numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写
g = np.char.title(a)
print(g)

#numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower
h = np.char.lower(a)
print(h)

#numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。
i = np.char.upper(a)
print(i)

#numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格
j = np.char.split(a,sep='a')
print(j)

#numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。
k = np.char.strip(a,'t')
print(k)

#numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
l = np.char.join(',',a)
print(l)

#numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
m = np.char.replace(a,'a','b')
print(m)

14、数学函数

#numpy.around() 函数返回指定数字的四舍五入值
a = np.array([1.0,5.55,  123,  0.567,  25.532]) 
print(np.around(a,decimals=1))
print(np.around(a))

#numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print(np.floor(a))

#numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print(np.ceil(a))

#三角函数
a = np.array([30,60,90,120,150,180])
print(np.sin(a*np.pi/180))
print(np.cos(a*np.pi/180))
print(np.tan(a*np.pi/180))

15、算术函数

#算术函数
a = np.arange(9, dtype = np.float_).reshape(3,3) 
b = np.array([10,10,10])
#add
print(np.add(a,b))
#subbtract
print(np.subtract(a,b))
#multiply
print(np.multiply(a,b))
#divide
print(np.divide(a,b))

#numpy.reciprocal() 函数返回参数逐元素的倒数
a = np.array([0.25,  1.33,  1,  100])
print(np.reciprocal(a))

#numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
a = np.array([10,20,30])
print(np.power(a,2))

#numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print(np.mod(a,b))

16、统计函数

a = np.arange(24).reshape(4,6)
print(a)

#numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
print(np.amin(a,axis=1))
print(np.amin(a,axis=0))

#numpy.amax() 用于计算数组中的元素沿指定轴的最大值
print(np.amax(a,axis=1))
print(np.amax(a,axis=0))

#numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(np.ptp(a))
print(np.ptp(a,axis=0))
print(np.ptp(a,axis=1))

#numpy.percentile()百分位数是统计中使用的度量，表示小于这个值的观察值的百分比
a = np.array([[10, 7, 4], [3, 2, 1]])
print(np.percentile(a,50))
print(np.percentile(a,50,axis=0))
print(np.percentile(a,50,axis=1))

#numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print(np.median(a))
print(np.median(a,axis=0))
print(np.median(a,axis=1))

#numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print(np.mean(a))
print(np.mean(a,axis=0))
print(np.mean(a,axis=1))

#numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值
a = np.array([1,2,3,4])
t = np.array([4,3,2,1])
print(np.average(a))
print(np.average(a,weights=t))

#标准差std = sqrt(mean((x - x.mean())**2))
print (np.std([1,2,3,4]))
#方差统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2）
print (np.var([1,2,3,4]))

17、排序、条件刷选函数

#numpy.sort() 函数返回输入数组的排序副本
a = np.array([[9,1],[3,7]])
print(a)
print(np.sort(a))
print(np.sort(a,axis=0))
print(np.sort(a,axis=1))

#numpy.argsort() 函数返回的是数组值从小到大的索引值
x = np.array([3,1,2])
print(np.argsort(x))

#numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。
nm =  ('raju','anil','ravi','amar') 
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
ind = np.lexsort((dv,nm))
print (ind) 
print ([nm[i]  +  ", "  + dv[i]  for i in ind])

#numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print(np.argmax(a))
print(np.argmax(a,axis=0))
print(np.argmax(a,axis=1))

print(np.argmin(a))
print(np.argmin(a,axis=0))
print(np.argmin(a,axis=1))

#numpy.nonzero() 函数返回输入数组中非零元素的索引
a = np.array([[30,40,0],[0,20,10],[50,0,60]]) 
np.nonzero(a)

#numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
x = np.arange(9.).reshape(3,  3) 
print(np.where(x>3))

#numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素
x = np.arange(9.).reshape(3,  3)
condition = np.mod(x,2)  ==  0 
print(np.extract(condition,x))

18、副本与视图

#赋值两者会被修改
a = np.arange(6)  
print ('我们的数组是：')
print (a)
print ('调用 id() 函数：')
print (id(a))
print ('a 赋值给 b：')
b = a 
print (b)
print ('b 拥有相同 id()：')
print (id(b))
print ('修改 b 的形状：')
b.shape =  3,2  
print (b)
print ('a 的形状也修改了：')
print (a)

#ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数据的维数。
# 最开始 a 是个 3X2 的数组
a = np.arange(6).reshape(3,2)  
print ('数组 a：')
print (a)
print ('创建 a 的视图：')
b = a.view()  
print (b)
print ('两个数组的 id() 不同：')
print ('a 的 id()：')
print (id(a))
print ('b 的 id()：' )
print (id(b))
# 修改 b 的形状，并不会修改 a
b.shape =  2,3
print ('b 的形状：')
print (b)
print ('a 的形状：')
print (a)

#使用切片创建视图修改数据会影响到原始数组
arr = np.arange(12)
print ('我们的数组：')
print (arr)
print ('创建切片：')
a=arr[3:]
b=arr[3:]
a[1]=123
b[2]=234
print(arr)
print(id(a),id(b),id(arr[3:]))

#ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置
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)