numpy中的数组对象相关操作

最新推荐文章于 2023-06-05 20:09:09 发布

码雲.py

最新推荐文章于 2023-06-05 20:09:09 发布

阅读量417

点赞数

分类专栏： DataAnalysis 文章标签： numpy

本文链接：https://blog.csdn.net/weixin_43814474/article/details/105660443

版权

DataAnalysis 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

numpy概述

Numerical Python，数值的Python，补充了Python语言所欠缺的数值计算能力。
Numpy是其它数据分析及机器学习库的底层库。
Numpy完全标准C语言实现，运行效率充分优化。
Numpy开源免费。

numpy核心

多维数组

代码简洁：减少Python代码中的循环。
底层实现：厚内核©+薄接口(Python)，保证性能。

ndarray数组

用np.ndarray类的对象表示n维数组

import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
print(type(a))

1. 内存中的ndarray对象

元数据（metadata）

存储对目标数组的描述信息，如：ndim、dtype、data等。

实际数据

完整的数组数据

优点
将实际数据与元数据分开存放，一方面提高了内存空间的使用效率，另一方面减少对实际数据的访问频率，提高性能。

特点

Numpy数组是同质数组，即所有元素的数据类型必须相同
Numpy数组的下标从0开始，最后一个元素的下标为数组长度减1

2. ndarray数组对象的创建

np.array(任何可被解释为Numpy数组的逻辑结构)

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

np.arange(起始值(0),终止值,步长(1))

import numpy as np
a = np.arange(0, 5, 1)
print(a)
b = np.arange(0, 10, 2)
print(b)

np.zeros(数组元素个数, dtype=‘类型’)

import numpy as np
a = np.zeros(10)
print(a)

np.ones(数组元素个数, dtype=‘类型’)

import numpy as np
a = np.ones(10)
print(a)

3. ndarray对象属性

数组维度： np.ndarray.shape

import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
print(type(a), a, a.shape)
#二维数组
b = np.array([
    [1,2,3,4],
    [5,6,7,8]
])
print(type(b), b, b.shape)

元素类型： np.ndarray.dtype

import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
print(type(a), a, a.dtype)
#转换元素的类型
b = ary.astype(float)
print(type(b), b, b.dtype)
c = ary.astype(str)
print(type(c), c, c.dtype)

元素个数： np.ndarray.size

import numpy as np
a = np.array([
    [1,2,3,4],
    [5,6,7,8]
])
#观察维度，size：元素总个数，len：数组长度
print(a.shape, a.size, len(a))

元素索引(下标)

数组对象[…, 页号, 行号, 列号]

下标从0开始，到数组len-1结束。

import numpy as np
a = np.array([[[1, 2],
               [3, 4]],
              [[5, 6],
               [7, 8]]])
print(a, a.shape)
print(a[0])
print(a[0][0])
print(a[0][0][0])
print(a[0, 0, 0])
for i in range(a.shape[0]):
    for j in range(a.shape[1]):
        for k in range(a.shape[2]):
            print(a[i, j, k])

其他属性

ndim - 维数，len(shape) 二维，三维
itemsize - 元素字节数
nbytes - 总字节数 = size x itemsize
real - 复数数组的实部数组
imag - 复数数组的虚部数组
T - 数组对象的转置视图
flat - 扁平迭代器

import numpy as np
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
              [4 + 2j, 5 + 5j, 6 + 8j],
              [7 + 3j, 8 + 6j, 9 + 9j]])
print(a.shape)
print(a.dtype)
print(a.ndim)
print(a.size)
print(a.itemsize)
print(a.nbytes)
print(a.real, a.imag, sep='\n')
print(a.T)
print([elem for elem in a.flat])
b = a.tolist()
print(b)

4. numpy的内部基本数据类型

类型名	类型表示符	字符码[字节数8bits=1byte]
布尔型	bool_	?
有符号整数型	int8(-128~127)/int16/int32/int64	i1/i2/i4/i8
无符号整数型	uint8(0~255)/uint16/uint32/uint64	u1/u2/u4/u8
浮点型	float16/float32/float64	f2/f4/f8
复数型	complex64/complex128	c8/c16
字串型	str_，每个字符用32位Unicode编码表示	U<字符数>
时间	datetime64	M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s]

自定义复合类型

# 自定义复合类型
import numpy as np

data=[
	('zs', [90, 80, 85], 15),
	('ls', [92, 81, 83], 16),
	('ww', [95, 85, 95], 15)
]
#第一种设置dtype的方式
a = np.array(data, dtype='U3, 3int32, int32')
print(a)
print(a[0]['f0'], ":", a[1]['f1'])

#第二种设置dtype的方式
b = np.array(data, dtype=[('name', 'str_', 2),
                    ('scores', 'int32', 3),
                    ('age', 'int32', 1)])
print(b[0]['name'], ":", b[0]['scores'])

#第三种设置dtype的方式
c = np.array(data, dtype={'names': ['name', 'scores', 'ages'],
                    'formats': ['U3', '3int32', 'int32']})
print(c[0]['name'], ":", c[0]['scores'], ":", c.itemsize)

#第四种设置dtype的方式   字节偏移量
d = np.array(data, dtype={'names': ('U3', 0),
                    'scores': ('3int32', 16),
                    'ages': ('int32', 28)})
print(d[0]['names'], d[0]['scores'], d.itemsize)

#测试日期类型数组
f = np.array(['2011', '2012-01-01', '2013-01-01 01:01:01','2011-02-01'])
f = f.astype('M8[D]')
f = f.astype('int32')
print(f[3]-f[0])

5. ndarray数组维度操作

视图变维（数据共享）： reshape() 与 ravel()

import numpy as np
a = np.arange(1, 9)
print(a)		# [1 2 3 4 5 6 7 8]
b = a.reshape(2, 4)	 # 变为2行4列的二维数组
print(b)
c = b.reshape(2, 2, 2)  # 变为2页2行2列的三维数组
print(c)
d = c.ravel()	# 变为1维数组
print(d)

复制变维（数据独立）： flatten() 变平深拷贝

e = c.flatten()
print(e)
a += 10
print(a, e, sep='\n')

就地变维： 直接改变原数组对象的维度，不返回新数组

a.shape = (2, 4)
print(a)
a.resize(2, 2, 2)
print(a)

6. ndarray数组切片操作

数组对象切片的参数设置与列表切片参数类似

数组对象[起始位置:终止位置:步长, ...]
步长+：默认切从首到尾
步长-：默认切从尾到首
默认位置步长：1

import numpy as np
a = np.arange(1, 10)
print(a)  # 1 2 3 4 5 6 7 8 9
print(a[:3])  # 1 2 3
print(a[3:6])   # 4 5 6
print(a[::-1])  # 9 8 7 6 5 4 3 2 1
print(a[:-4:-1])  # 9 8 7
print(a[-4:-7:-1])  # 6 5 4
print(a[-7::-1])  # 3 2 1
print(a[::])  # 1 2 3 4 5 6 7 8 9
print(a[:])  # 1 2 3 4 5 6 7 8 9
print(a[::3])  # 1 4 7
print(a[1::3])  # 2 5 8
print(a[2::3])  # 3 6 9

掩码操作： 布尔掩码

import numpy as np
a = np.arange(1, 10)
mask = [True, False,True, False,True, False,True, False,True, False]
print(a[mask])

多维数组的切片操作

import numpy as np
a = np.arange(1, 28)
a.resize(3,3,3)
print(a)
#切出1页 
print(a[1, :, :])		
#切出所有页的1行
print(a[:, 1, :])		
#切出0页的1行1列
print(a[0, :, 1])

7. 数组的组合与拆分

垂直方向操作：

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))
# 垂直方向完成拆分操作，生成两个数组
d, e = np.vsplit(c, 2)

水平方向操作：

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 水平方向完成组合操作，生成新数组 
c = np.hstack((a, b))
# 水平方向完成拆分操作，生成两个数组
d, e = np.hsplit(c, 2)

长度不等的数组组合：

import numpy as np
a = np.array([1,2,3,4,5])
b = np.array([1,2,3,4])
# 填充b数组使其长度与a相同
b = np.pad(b, pad_width=(0, 1), mode='constant', constant_values=-1)
print(b)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))
print(c)

深度方向操作：（3维）

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 深度方向（3维）完成组合操作，生成新数组
i = np.dstack((a, b))
# 深度方向（3维）完成拆分操作，生成两个数组
k, l = np.dsplit(i, 2)

多维数组组合与拆分的相关函数：

# 通过axis作为关键字参数指定组合的方向，取值如下：
# 若待组合的数组都是二维数组：
#	0: 垂直方向组合
#	1: 水平方向组合
# 若待组合的数组都是三维数组：
#	0: 垂直方向组合
#	1: 水平方向组合
#	2: 深度方向组合
np.concatenate((a, b), axis=0)
# 通过给出的数组与要拆分的份数，按照某个方向进行拆分，axis的取值同上
np.split(c, 2, axis=0)

简单的一维数组组合：

a = np.arange(1,9)		#[1, 2, 3, 4, 5, 6, 7, 8]
b = np.arange(9,17)		#[9,10,11,12,13,14,15,16]
#把两个数组摞在一起成两行
c = np.row_stack((a, b))
print(c)
#把两个数组组合在一起成两列
d = np.column_stack((a, b))
print(d)

numpy通用函数

1. 数组处理函数

# 将调用数组中小于下限和大于上限的元素替换为下限和上限，返回裁剪后的数组，调用数组保持不变。
ndarray.clip(min=下限, max=上限)
# 返回由调用数组中满足条件的元素组成的新数组。
ndarray.compress(条件)
# 返回数组的符号数组
np.sign(array)

案例：

# 数组裁剪和压缩
import numpy as np

a = np.array([10, 20, 30, 40, 50])
print(a)  # [10 20 30 40 50]
b = a.clip(min=15, max=45)  # 裁剪，将范围之外的部分置为min,max
print(b)  # [15 20 30 40 45]
c = a.compress((a >= 15) & (a <= 45))  # 压缩，保留满足条件的部分
print(c)  # [20 30 40]

2. 加法与乘法通用函数

np.add(a, a) 					# 两数组相加
np.add.reduce(a) 				# a数组元素累加和，返回一个值
np.add.accumulate(a) 			# 累加和过程
np.add.outer([10, 20, 30], a)	# 外和
np.prod(a)# 返回数组元素在给定轴上的乘积
np.cumprod(a) # 返回数组中所有元素执行累乘的过程数组
np.outer([10, 20, 30], a)

案例：

import numpy as np

a = np.arange(1, 7)  # [1 2 3 4 5 6]
# b = a + a  [ 2  4  6  8 10 12]
b = np.add(a, a)  # [ 2  4  6  8 10 12]
c = np.add.reduce(a)  # 21
# 每个元素和前面元素相加的到新的数组
d = np.add.accumulate(a)  # [ 1  3  6 10 15 21]
f = np.add.outer([10, 20, 30], a)  # 外和
#  +  	 1  2  3  4  5  6
#	   --------------------
# 10   |11 12 13 14 15 16 |
# 20   |21 22 23 24 25 26 |
# 30   |31 32 33 34 35 36 |
#      --------------------
g = np.outer([10, 20, 30], a)  # 外积
#  x  	 1  2  3  4  5  6
#	   -----------------------
# 10   |10 20 30  40  50  60 |
# 20   |20 40 60  80 100 120 |
# 30   |30 60 90 120 150 180 |
#      -----------------------

3. 除法与取整通用函数

np.divide(a, b) 	# a 真除 b
np.floor(a / b)		# （真除的结果向下取整）
np.ceil(a / b) 		# （真除的结果向上取整）
np.trunc(a / b)		# （真除的结果截断取整）
np.round(a / b)		# （真除的结果四舍五入取整）

案例：

import numpy as np

a = np.array([10, 20, -30])
b = np.array([3, -3, 6])
# 真除
# c = a / b 
c = np.divide(a, b)  # array: [ 3.33333333 -6.66666667 -5.        ]
d = np.floor(a / b)  # floor_divide: [ 3. -7. -5.]
e = np.ceil(a / b)  # ceil ndarray: [ 4. -6. -5.]
f = np.trunc(a / b)  # trunc ndarray: [ 3. -6. -5.]
g = np.around(a / b)  # around ndarray: [ 3. -7. -5.]

4. 位运算通用函数

# 位异或：
c = a ^ b
c = np.bitwise_xor(a, b)
# 位与：
e = a & b
e = np.bitwise_and(a, b)
# 位或：
e = a | b
e = np.bitwise_or(a, b)
# 位反：
e = ~a
e = np.bitwise_not(a, b)
# 移位：
<<		__lshift__		left_shift
>>		__rshift__		right_shift

a = np.array([0, -1, 2, -3, 4, -5])
b = np.array([0, 1, 2, 3, 4, 5])
print(a, b)
c = a ^ b
# c = a.__xor__(b)
# c = np.bitwise_xor(a, b)
print(np.where(c < 0)[0])

按位异或操作可以很方便的判断两个数据是否同号。结果小于0，异号

利用位与运算计算某个数字是否是2的幂 a&(a-1) = 0 即为2的幂

#  1 2^0 00001   0 00000
#  2 2^1 00010   1 00001
#  4 2^2 00100   3 00011
#  8 2^3 01000   7 00111
# 16 2^4 10000  15 01111
# ...

d = np.arange(1, 21)
print(d)
e = d & (d - 1)
e = d.__and__(d - 1)
e = np.bitwise_and(d, d - 1)
print(e)