numpy中级学习

"""
numpy下的常见方法：
    all，any，argmax， argmin，argpartition，argsort，choose， clip，
    compress，copy，cumprod， cumsum，diagonal，imag，max， mean，min，
    nonzero，partition， prod，ptp，put，ravel，real， repeat，reshape，
    round， searchsorted，sort，squeeze，std， sum，swapaxes，take，trace，
    transpose，var。

ndarray属性:
    ndarray.flags有关阵列的内存布局的信息。
    ndarray.shape数组维度的元组。
    ndarray.strides在遍历数组时在每个维度上步进的字节元组。
    ndarray.ndim数组维数。
    ndarray.data指向数组数据开头的Python缓冲区对象。
    ndarray.size数组中元素的数量。
    ndarray.itemsize一个数组元素的长度（以字节为单位）。
    ndarray.nbytes数组元素消耗的总字节数。
    ndarray.base如果内存来自其他对象，则为基础对象。
    ndarray.dtype数组元素的数据类型。
    ndarray.T转置数组。
    ndarray.real数组的实部。
    ndarray.imag数组的虚部。
    ndarray.flat数组上的一维迭代器。
    ndarray.ctypes一个用于简化数组与ctypes模块的交互的对象。
    
ndarray转换：
    ndarray.item(*args)将数组的元素复制到标准Python标量并返回。
    ndarray.tolist()将数组作为a.ndimPython标量的-levels深度嵌套列表返回。
    ndarray.itemset(*args)将标量插入数组中（如果可能，将标量强制转换为数组的dtype）
    ndarray.tobytes([order])在数组中构造包含原始数据字节的Python字节。
    ndarray.tofile(fid[, sep, format])将数组以文本或二进制形式写入文件（默认）。
    ndarray.dumps()以字符串形式返回数组的泡菜。
    ndarray.astype(dtype[, order, casting, …])数组的副本，强制转换为指定的类型。
    ndarray.byteswap([inplace])交换数组元素的字节
    ndarray.copy([order])返回数组的副本。
    ndarray.view([dtype, type])具有相同数据的数组的新视图。
    ndarray.getfield(dtype[, offset])以给定类型返回给定数组的字段。
    ndarray.fill(value)用标量值填充数组。
    
    
ndarray形状操作：
    ndarray.reshape(shape[, order])返回一个数组，其中包含具有相同形状的相同数据。
    ndarray.resize(new_shape[, refcheck])就地更改数组的形状和大小。
    ndarray.transpose(*axes)就地更改数组的形状和大小。
    ndarray.swapaxes(axis1, axis2)返回轴1和轴2互换的数组视图。
    ndarray.flatten([order])返回折叠成一维的数组副本。
    ndarray.ravel([order])返回一个展平的数组。
    ndarray.squeeze([axis])从形状除去单维输入一个。

ndarray选择和操作：
  ndarray.take(indices, axis=None, out=None, mode='raise')返回来自的元素构成的数组一个在给定的索引。

ndarray方法：
    ndarray.max([axis, out, keepdims, initial, …])沿给定轴返回最大值。
    ndarray.argmax([axis, out])沿给定轴返回最大值的索引。
    ndarray.min([axis, out, keepdims, initial, …])沿给定轴返回最小值。
    ndarray.argmin([axis, out])返回最小值的索引沿给定轴线一个。
    ndarray.ptp([axis, out, keepdims])沿给定轴的峰到峰（最大值-最小值）值。
    ndarray.clip([min, max, out])返回值限制为的数组。[min, max]
    ndarray.conj()将所有元素复数共轭
    ndarray.round([decimals, out])返回一个与舍入到小数的给定数目的每个元素。
    ndarray.trace([offset, axis1, axis2, dtype, out])返回数组对角线的和。
    ndarray.sum([axis, dtype, out, keepdims, …])返回给定轴上数组元素的总和。
    ndarray.cumsum([axis, dtype, out])返回沿给定轴的元素的累加和。
    ndarray.mean([axis, dtype, out, keepdims])返回沿给定轴的数组元素的平均值。
    ndarray.var([axis, dtype, out, ddof, keepdims])返回沿给定轴的数组元素的方差。
    ndarray.std([axis, dtype, out, ddof, keepdims])返回沿给定轴的数组元素的标准偏差。
    ndarray.prod([axis, dtype, out, keepdims, …])返回给定轴上数组元素的乘积
    ndarray.cumprod([axis, dtype, out])返回沿给定轴的元素的累积积。
    ndarray.all([axis, out, keepdims])如果所有元素的评估结果为True，则返回True。
    ndarray.any([axis, out, keepdims])如果任何元素，则返回true 一个评估为True。
"""

<class 'numpy.ndarray'>
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

(2, 3)
(12, 4)
2
<memory at 0x00000188A8DCAE48>
6
4
24
int32
<numpy.core._internal._ctypes object at 0x00000188A9E152C8>
[[1 4]
 [2 5]
 [3 6]]
[[1 2 3]
 [4 5 6]]
[[0 0 0]
 [0 0 0]]

# ndarray属性:
import numpy as np
x=np.array([[1,2,3],[4,5,6]],np.int32)

# print(type(x))#显示对象类型
# # <class 'numpy.ndarray'>：就有一下属性

print(x)
'''
[[1 2 3]
 [4 5 6]]
'''

print(x.flags)#有关阵列的内存布局的信息
'''
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

'''
print(x.shape)#数组维度的元组【对象形状】
'''
(2, 3)
'''
print(x.strides)#在遍历数组时在每个维度上步进的字节元组
'''
(12, 4)
'''
print(x.ndim)#数组维数
'''
2
'''
print(x.data)#指向数组数据开头的Python缓冲区对象
'''
<memory at 0x0000025B7C2A9C88>
'''
print(x.size)#数组中元素的数量
'''
6
'''
print(x.itemsize)#一个数组元素的长度（以字节为单位）
'''
4
'''
print(x.nbytes)#数组元素消耗的总字节数
'''
24
'''
print(x.dtype)#数组元素的数据类型
'''
int32
'''
print(x.ctypes)#一个用于简化数组与ctypes模块的交互的对象
'''
<numpy.core._internal._ctypes object at 0x0000025B7D2BDF88>
'''
print(x.T)#转置数组
'''
[[1 4]
 [2 5]
 [3 6]]
'''
print(x.real)#数组的实部
'''
[[1 2 3]
 [4 5 6]]
'''
print(x.imag)#数组的虚部
'''
[[0 0 0]
 [0 0 0]]
'''

# ndarray转换：
import numpy as np
x=np.array([[1,2,3],[4,5,6]],np.int32)

print(x.item(1))#第一行第二列数据
'''
2
'''
print(x.item((1,2)))#第二行第三列数据
'''
6
'''
print(x.tolist())#把ndarray类型转换为list
print(type(x.tolist()))
'''
[[1, 2, 3], [4, 5, 6]]
<class 'list'>
'''
x.itemset(5,9)#类似展平后替换数据
print(x)#显示结果
'''
[[1 2 3]
 [4 5 9]]
'''
print(x.tobytes())#转换为字节
'''
b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00'
'''
x.tofile("x.bin")##类似展平后保存文件
tmp=np.fromfile("x.bin",dtype=np.int32)#读取文件
print(tmp)#显示结果
'''
[1 2 3 4 5 6]
'''
tmp=x.astype(np.int64)#强制转换为指定的类型
print(tmp.dtype)#显示结果
'''
int64
'''
tmp=x.copy()#数组的副本【numpy的深拷贝】
print(tmp)#显示结果
tmp[0]=99
print(tmp)
print(x)#原始数据不变
'''
[[1 2 3]
 [4 5 6]]
[[99 99 99]
 [ 4  5  6]]
[[1 2 3]
 [4 5 6]]
'''
tmp=x.view()#具有相同数据的数组的新视图【numpy的浅拷贝】
print(tmp)#显示结果
tmp[0]=99
print(tmp)
print(x)#原始数据也随着改变
'''
[[1 2 3]
 [4 5 6]]
[[99 99 99]
 [ 4  5  6]]
[[99 99 99]
 [ 4  5  6]]
'''
map(hex,x)#以十六进制表示内存中的数据
print(x)#对原始数据不影响
print(x.byteswap(True))#查看x存储在内存的数据
'''
[[1 2 3]
 [4 5 6]]
[[ 16777216  33554432  50331648]
 [ 67108864  83886080 100663296]]
'''
print(x)
x.fill(0)#填充0，就是把全部数据换成0
print(x)#显示结果
'''
[[1 2 3]
 [4 5 6]]
[[0 0 0]
 [0 0 0]]
'''
import pickle
tmp=x.dumps()#转换类型
# print(tmp)#一大推的bytes类型数据
print(type(x))#<class 'numpy.ndarray'>
print(type(tmp))#<class 'bytes'>
print(pickle.loads(tmp))#加载并显示数据
'''
<class 'numpy.ndarray'>
<class 'bytes'>
[[1 2 3]
 [4 5 6]]
'''


x2 = np.diag([1.+1.j]*2)#输出矩阵的对角线元素
x2[1, 1] = 2 + 4.j
print(x2)#显示结果
print(type(x2))
print(x2.dtype)#复数类型
print(x2[0,0].itemsize)##一个数组元素的长度（以字节为单位）
print(x2.getfield(np.float64))#offset默认为0
print(x2.getfield(np.float64,offset=8))#获取复数前面的数字
'''
[[1.+1.j 0.+0.j]
 [0.+0.j 2.+4.j]]
<class 'numpy.ndarray'>
complex128
16
[[1. 0.]
 [0. 2.]]
[[1. 0.]
 [0. 4.]]
'''
print()

# ndarray形状操作：
# a=np.arange(12).reshape((3,4))
# print(a)#显示结果
# print(np.reshape(a, (4, 3)))#横着获取数据
# print(np.reshape(a, (4, 3), order='F'))#斜向下获取
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
[[ 0  5 10]
 [ 4  9  3]
 [ 8  2  7]
 [ 1  6 11]]
'''
# a=np.arange(12).reshape((3,4))
# print(a)
# a.resize(2,6)#在本身上进行操作
# print(a)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
'''

# a=np.arange(12).reshape((3,4))
# print(a.transpose((1,0)))#把列转换为行
# b=np.arange(16).reshape((2,2,4))
# print(b.transpose(1,2,0))#两对三位数组的转换并重组
# print(b.swapaxes(2,1))#自己三维数组的转换并重组
'''
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
[[[ 0  8]
  [ 1  9]
  [ 2 10]
  [ 3 11]]

 [[ 4 12]
  [ 5 13]
  [ 6 14]
  [ 7 15]]]
[[[ 0  4]
  [ 1  5]
  [ 2  6]
  [ 3  7]]

 [[ 8 12]
  [ 9 13]
  [10 14]
  [11 15]]]
'''
# a=np.arange(12).reshape((3,4))
# b=np.arange(16).reshape((2,2,4))
# print(a.flatten())#展平数组【类似numpy的copy】
# print(b.flatten())#展平数组
# print(a.ravel())#展平数组【类似numpy的view】
# print(b.ravel())#展平数组
# c=np.arange(3).reshape(3,1)
# print(a.squeeze())#展平数组【只能对维数为1的维度降维】
# print(b.squeeze())#展平数组【只能对维数为1的维度降维】
# print(c.squeeze())#可以展平
'''
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]
[0 1 2]
'''
print()

# ndarray选择和操作：
# numpy.take(a, indices, axis=None, out=None, mode='raise')沿轴从数组中获取元素。
# numpy.put(a, ind, v, mode='raise')用给定值替换数组的指定元素。
# numpy.repeat(a, repeats, axis=None)重复数组的元素。
# numpy.choose(a, choices, out=None, mode='raise')从索引数组和一组数组中构造一个数组以供选择。
# numpy.sort(a, axis=-1, kind=None, order=None)返回数组的排序副本。
# numpy.argsort(a, axis=-1, kind=None, order=None)返回将对数组进行排序的索引。
# numpy.searchsorted(a, v, side='left', sorter=None)查找应在其中插入元素以保持顺序的索引。
# numpy.nonzero(a)返回非零元素的索引。
# numpy.compress(condition, a, axis=None, out=None)沿给定轴返回数组的选定切片。
# numpy.diagonal(a, offset=0, axis1=0, axis2=1)返回指定的对角线


a = np.arange(1,6)#原始数据
indices = [0, 1, 4]#要获取的下标列表
print(np.take(a, indices))#根据下标取值，返回一维数组
print(a[indices])#同上
indices=[[0, 1], [3, 4]]
print(np.take(a, indices))#根据下标取值，返回二维数组
'''
[1 2 5]
[1 2 5]
[[1 2]
 [4 5]]
'''
a = np.arange(5)
np.put(a, [0, 2], [-44, -55])
print(a)
b = np.arange(5)
np.put(b, 22, -5, mode='clip')#clip:修剪（下标超出就放在最后一位）
print(b)
'''
[1 2 5]
[1 2 5]
[[1 2]
 [4 5]]
[-44   1 -55   3   4]
[ 0  1  2  3 -5]
'''
print(np.repeat(3, 4))#创建一维数组，3重复4次
x = np.array([[1,2],[3,4]])
print(np.repeat(x, 2))#展平数据后，再重复每个数值2次
print(np.repeat(x, 3, axis=1))#不展平数据，二维数据的每一行数值重复3次
print(np.repeat(x, [1, 2], axis=0))#不展平数据，二维数组的除了第一行每一行重复2次
'''
[3 3 3 3]
[1 1 2 2 3 3 4 4]
[[1 1 1 2 2 2]
 [3 3 3 4 4 4]]
[[1 2]
 [3 4]
 [3 4]]
'''
choices = [[0, 1, 2, 3], [10, 11, 12, 13],[20, 21, 22, 23], [30, 31, 32, 33]]
choices=np.array(choices)
print(choices)
print(np.choose([2, 3, 1, 0], choices))#获取第一列第三行数值，第二列第四行数值....
print(np.choose([2, 4, 1, 0], choices, mode='clip'))#clip:修剪（下标超出就放在最后一位）
'''
[[ 0  1  2  3]
 [10 11 12 13]
 [20 21 22 23]
 [30 31 32 33]]
[20 31 12  3]
[20 31 12  3]
'''
a = np.array([[1,4],[3,1]])
print(np.sort(a, axis=None))#类似展平再排序
print(np.sort(a, axis=0))#按列排序
print(np.sort(a, axis=1))#按行排序
'''
[1 1 3 4]
[[1 1]
 [3 4]]
[[1 4]
 [1 3]]
'''
x = np.array([3, 1, 2])
print(np.argsort(x))#返回数值排序大小的下标
x = np.array([[0, 3], [1, 2]])
print(np.argsort(x, axis=0))#返回数值排序大小的下标【按列排序】
print(np.argsort(x, axis=1))#返回数值排序大小的下标【按行排序】
'''
[1 2 0]
[[0 1]
 [1 0]]
[[0 1]
 [0 1]]
'''
print(np.searchsorted([1,2,3,4,5], 3))#插入并查询下标，默认插入到左边
print(np.searchsorted([1,2,3,4,5], 3, side='right'))#插入到右边，并返回下标
print(np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]))#不是同时插入
'''
2
3
[0 5 1 2]
'''
x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
tmp=np.nonzero(x)#返回非零元素的索引。
print(tmp[0])#二维数组的行
print(tmp[1])#二维数组的列
print(np.transpose(np.nonzero(x)))#显示更清楚的下标
print(x[np.nonzero(x)])#获取非零元素的值
'''
[0 1 2 2]
[0 1 0 1]
[[0 0]
 [1 1]
 [2 0]
 [2 1]]
[3 4 5 6]
'''
a = np.array([[1, 2], [3, 4], [5, 6]])
print(np.compress([0, 1], a, axis=0))#除了0是False，其他的都是True
print(np.compress([False, True], a, axis=0))#同上【读取第二行】
print(np.compress([0, 1], a, axis=1))#除了0是False，其他的都是True
print(np.compress([False, True], a, axis=1))#同上【读取第二列】
print(np.compress([0, 1, 1], a, axis=0))#除了0是False，其他的都是True
print(np.compress([False, True, True], a, axis=0))#同上【读取第二，第三行】
# print(np.compress([False, True, True], a, axis=1))#【出错：没有第三列】
'''
[[3 4]]
[[3 4]]
[[2]
 [4]
 [6]]
[[2]
 [4]
 [6]]
[[3 4]
 [5 6]]
[[3 4]
 [5 6]]
'''
a = np.arange(9).reshape(3,3)
print(a)
print(a.diagonal())#斜向下的对角线
print(a.diagonal(1))
print(a.diagonal(2))
'''
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[0 4 8]
[1 5]
[2]
'''
a = np.arange(27).reshape(3,3,3)
print(a)
print(a.diagonal(0))#三维数组的第一个的对角线
print(a.diagonal(1))#三维数组的前第两个第二行
print(a.diagonal(2))#三维数组的第一个第三行
'''
[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]]

 [[ 9 10 11]
  [12 13 14]
  [15 16 17]]

 [[18 19 20]
  [21 22 23]
  [24 25 26]]]
[[ 0 12 24]
 [ 1 13 25]
 [ 2 14 26]]
'''
print()