python数据处理（numpy）

最新推荐文章于 2024-06-15 21:11:18 发布

和安韩Pro

最新推荐文章于 2024-06-15 21:11:18 发布

阅读量324

点赞数

分类专栏： python 文章标签： python numpy 开发语言

本文链接：https://blog.csdn.net/weixin_45714641/article/details/138504257

版权

python 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

本文介绍了如何在Python中使用numpy库进行数组操作，包括列表与数组的区别、数据类型管理、数组生成方法、随机数生成、数组运算、统计功能、排序和拼接等实用技巧。

摘要由CSDN通过智能技术生成

numpy # 数据分析库
pandas # 数据分析库
matplotlib # 绘图库

numpy
数组跟列表，列表可以存储任意类型的数据，而数组只能存储一种类型的数据

import array
a = array.array('i',range(10))
a[1] = 1
# 数据类型必须统一
a[1] = 10
a

array('i', [0, 10, 2, 3, 4, 5, 6, 7, 8, 9])

import numpy as np #as用来起别名

# 通过原有列表转换为数组
a_list = list(range(10))
b = np.array(a_list)
type(b)

numpy.ndarray

生成数组的一些方法

# 生成数组
a = np.zeros(10, dtype=int)
print(type(a))
# 查看数组类型
print(a.dtype)

<class 'numpy.ndarray'>
int32

# 生成数组
a = np.zeros((4,4), dtype = int)
print(type(a))
# 查看数组类型
a.dtype
a

<class 'numpy.ndarray'>





array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]])

np.ones((4,4), dtype = float)

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

np.full((3,3), 3.14)

array([[3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14]])

array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]])

np.zeros_like(a)

array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]])

np.ones_like(a)

array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])

np.full_like(a, 4.12, dtype = float)

array([[4.12, 4.12, 4.12, 4.12],
       [4.12, 4.12, 4.12, 4.12],
       [4.12, 4.12, 4.12, 4.12],
       [4.12, 4.12, 4.12, 4.12]])

# random库：生成随机数
import random
print(random.randint(5,10))
print(random.random())

5
0.35946686697962893

np.random.random((3,3))

array([[0.9309985 , 0.35954914, 0.79636295],
       [0.94452565, 0.20042206, 0.28679772],
       [0.80528383, 0.1809585 , 0.4296256 ]])

# 经常会用到
# 从0-10取一个3*3的二维数组
np.random.randint(0,10,(3,3))

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

list(range(0,10,2))

[0, 2, 4, 6, 8]

np.arange(0,10,2)

array([0, 2, 4, 6, 8])

# 经常用到
# 从0-3取100个随机数
np.linspace(0,3,100)

array([0.        , 0.03030303, 0.06060606, 0.09090909, 0.12121212,
       0.15151515, 0.18181818, 0.21212121, 0.24242424, 0.27272727,
       0.3030303 , 0.33333333, 0.36363636, 0.39393939, 0.42424242,
       0.45454545, 0.48484848, 0.51515152, 0.54545455, 0.57575758,
       0.60606061, 0.63636364, 0.66666667, 0.6969697 , 0.72727273,
       0.75757576, 0.78787879, 0.81818182, 0.84848485, 0.87878788,
       0.90909091, 0.93939394, 0.96969697, 1.        , 1.03030303,
       1.06060606, 1.09090909, 1.12121212, 1.15151515, 1.18181818,
       1.21212121, 1.24242424, 1.27272727, 1.3030303 , 1.33333333,
       1.36363636, 1.39393939, 1.42424242, 1.45454545, 1.48484848,
       1.51515152, 1.54545455, 1.57575758, 1.60606061, 1.63636364,
       1.66666667, 1.6969697 , 1.72727273, 1.75757576, 1.78787879,
       1.81818182, 1.84848485, 1.87878788, 1.90909091, 1.93939394,
       1.96969697, 2.        , 2.03030303, 2.06060606, 2.09090909,
       2.12121212, 2.15151515, 2.18181818, 2.21212121, 2.24242424,
       2.27272727, 2.3030303 , 2.33333333, 2.36363636, 2.39393939,
       2.42424242, 2.45454545, 2.48484848, 2.51515152, 2.54545455,
       2.57575758, 2.60606061, 2.63636364, 2.66666667, 2.6969697 ,
       2.72727273, 2.75757576, 2.78787879, 2.81818182, 2.84848485,
       2.87878788, 2.90909091, 2.93939394, 2.96969697, 3.        ])

# n维的单位矩阵
np.eye(10)

array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

访问数组中的元素

# 嵌套列表的元素访问
var = [[1,2,3],[3,4,5],[5,6,7]]
var[0][0]

# 数组中元素的访问
a = np.array(var)
a

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

# 这两种访问方式是等价的
a[0,0],a[0][0]

(1, 1)

# 数组切片
a[:2, :2]

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

#同上面的方式是不等价的
a[:2][:2]

array([[1, 2, 3],
       [3, 4, 5]])

数组属性

# 维度
print('a的维度为：%s'%(a.ndim))
# 形状
print('a的形状为：{}'.format(a.shape))
# 尺寸
print('a的尺寸为：%s'%(a.size))
# 数据类型
print('a的数据类型为：%s'%(a.dtype))
# 每一个数据的字节数
print('a的每一个数据的字节数为：%s'%(a.itemsize))
# 所有数据的字节数
print('a的所有数据的字节数为：%s'%(a.nbytes))

a的维度为：2
a的形状为：(3, 3)
a的尺寸为：9
a的数据类型为：int32
a的每一个数据的字节数为：4
a的所有数据的字节数为：36

运算

a = np.array(list(range(10)))
a

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

print(a + 10)
print(a - 10)
print(a * 10)

[10 11 12 13 14 15 16 17 18 19]
[-10  -9  -8  -7  -6  -5  -4  -3  -2  -1]
[ 0 10 20 30 40 50 60 70 80 90]

a = np.full((3,3), 1.0, dtype=float)
a + 10 #等价于np.add(a, 10)

array([[11., 11., 11.],
       [11., 11., 11.],
       [11., 11., 11.]])

a = np.linspace(1,np.pi,5)
b = np.sin(a)
print(a)
print(b)

[1.         1.53539816 2.07079633 2.60619449 3.14159265]
[8.41470985e-01 9.99373550e-01 8.77582562e-01 5.10183526e-01
 1.22464680e-16]

统计类型

# 求和
print(sum([1,2,3,4,5,6]))
#数组一维求和
a = np.full(10,2.3)
print(sum(a))
#数组多维求和
a = np.array([[1,2],[3,4]])
print(sum(a))
#np.sum求和
np.sum(a)
np.sum(a,axis=1)
np.max(a,axis=1)

21
23.000000000000004
[4 6]





array([2, 4])

n = np.random.rand(1000)

notebook使用小技巧

%timeit 代码；此方法来判断程序的执行效率

%timeit sum(n)

133 µs ± 2.11 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit np.sum(n)

3.81 µs ± 113 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

由上代码可以看出np.sum的执行效率高，推荐使用

比较

a = np.array(range(10))
a

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

a > 3

array([False, False, False, False,  True,  True,  True,  True,  True,
        True])

a != 3

array([ True,  True,  True, False,  True,  True,  True,  True,  True,
        True])

np.all(a > -1)

True

np.any(a > -1)

True

变形

a = np.full((2,10),1, dtype = float)
a

array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

a.reshape(4,5)

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

排序

l = [
    [1,2,3],
    [34,12,4],
    [32,2,33]
]
a = np.array(l)
a

array([[ 1,  2,  3],
       [34, 12,  4],
       [32,  2, 33]])

# 按列去排列，a不跟着改变
print(np.sort(a))
print(a)
# 按行去排列，a跟着改变
a.sort(axis=0)
print(a)
# 按列去排列，a跟着改变
a.sort(axis=1)
print(a)

[[ 1  2  3]
 [ 2  4 32]
 [12 33 34]]
[[ 1  2  3]
 [32  2  4]
 [34 12 33]]
[[ 1  2  3]
 [32  2  4]
 [34 12 33]]
[[ 1  2  3]
 [ 2  4 32]
 [12 33 34]]

拼接

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

# 按行去连接
np.concatenate([b,b,b],axis=0)

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

# 按列去连接
np.concatenate([b,b,b],axis=1)

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

和安韩Pro

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录