1.python数据分析与展示----Numpy

最新推荐文章于 2024-03-06 00:37:02 发布

bxg1065283526

最新推荐文章于 2024-03-06 00:37:02 发布

阅读量590

点赞数 1

分类专栏： python数据分析文章标签： python numpy

本文链接：https://blog.csdn.net/bxg1065283526/article/details/80106306

版权

python数据分析专栏收录该内容

8 篇文章 1 订阅

订阅专栏

1.数据的维度

一维数据：一维数据由对等关系的有序或无序数据构成，采用线性方式组织，如：

3.1413, 3.1398, 3.1404, 3.1401, 3.1349, 3.1376

对应列表、数组和集合等概念

列表和数组的区别：

列表：数据类型可以不同如： 3.1413, 'pi', 3.1404, [3.1401, 3.1349], '3.1376'

数组：数据类型相同如：3.1413, 3.1398, 3.1404, 3.1401, 3.1349, 3.1376

二维数据：二维数据由多个一维数据构成，是一维数据的组合形式

表格是典型的二维数据其中，表头是二维数据的一部分，如下图

多维数据：多维数据由一维或二维数据在新维度上扩展形成

高维数据：高维数据仅利用最基本的二元关系展示数据间的复杂结构

数据维度的Python表示:数据维度是数据的组织形式

2.Numpy

NumPy是一个开源的Python科学计算基础库，包含：

•一个强大的N维数组对象ndarray

•广播功能函数

•整合C/C++/Fortran代码的工具

•线性代数、傅里叶变换、随机数生成等功能

NumPy是SciPy、Pandas等数据处理或科学计算库的基础

1.数组对象ndarray

python数组类型与ndarray的区别:

•数组对象可以去掉元素间运算所需的循环，使一维向量更像单个数据

•设置专门的数组对象，经过优化，可以提升这类应用的运算速度

ndarray是一个多维数组对象，由两部分构成：

•实际的数据

•描述这些数据的元数据（数据维度、数据类型等）

ndarray数组一般要求所有元素类型相同（同质），数组下标从0开始

ndarray对象的属性

ndarray数组的元素类型

对比：Python语法仅支持整数、浮点数和复数3种类型
•科学计算涉及数据较多，对存储和性能都有较高要求
•对元素类型精细定义，有助于NumPy合理使用存储空间并优化性能

•对元素类型精细定义，有助于程序员对程序规模有合理评估

ndarray数组的创建方法

①从Python中的列表、元组等类型创建ndarray数组

import numpy as np

x=np.array([1,2,3,4])#从列表类型创建
print(x)
x=np.array((1,2,3,4))#从元组类型创建
print(x)
x=np.array([[1,2,3,4],(1,2,3,4)])#从列表和元组混合类型创建
print(x)

[1 2 3 4]
[1 2 3 4]
[[1 2 3 4]
 [1 2 3 4]]

②使用NumPy中函数创建ndarray数组，如：arange, ones, zeros等

print(np.arange(10))
#[0 1 2 3 4 5 6 7 8 9]
print(np.ones((3,6)))
# [[1. 1. 1. 1. 1. 1.]
#  [1. 1. 1. 1. 1. 1.]
#  [1. 1. 1. 1. 1. 1.]]
print(np.zeros((3,6),dtype=np.int32))
# [[0 0 0 0 0 0]
#  [0 0 0 0 0 0]
#  [0 0 0 0 0 0]]
print(np.eye(5))
# [[1. 0. 0. 0. 0.]
#  [0. 1. 0. 0. 0.]
#  [0. 0. 1. 0. 0.]
#  [0. 0. 0. 1. 0.]
#  [0. 0. 0. 0. 1.]]
x=np.ones((2,3,4));
print(x)
# [[[1. 1. 1. 1.]
#   [1. 1. 1. 1.]
#   [1. 1. 1. 1.]]
#
#  [[1. 1. 1. 1.]
#   [1. 1. 1. 1.]
#   [1. 1. 1. 1.]]]
print(x.shape)
#(2, 3, 4)

③使用NumPy中其他函数创建ndarray数组

a=np.linspace(1,10,4)
print(a)
#[ 1.  4.  7. 10.]
b=np.linspace(1,10,4,endpoint=False)
print(b)
# [1.   3.25 5.5  7.75]
print(np.concatenate((a,b)))
# [ 1.    4.    7.   10.    1.    3.25  5.5   7.75]

3.ndarray数组的变换

对于创建后的ndarray数组，可以对其进行维度变换和元素类型变换

a=np.ones((2,3,4),dtype=np.int32)
print(a.reshape((3,8)))
# [[1 1 1 1 1 1 1 1]
#  [1 1 1 1 1 1 1 1]
#  [1 1 1 1 1 1 1 1]]
print(a)
# [[[1 1 1 1]
#   [1 1 1 1]
#   [1 1 1 1]]
#
#  [[1 1 1 1]
#   [1 1 1 1]
#   [1 1 1 1]]]
a.resize((3,8))
print(a)
# [[1 1 1 1 1 1 1 1]
#  [1 1 1 1 1 1 1 1]
#  [1 1 1 1 1 1 1 1]]

astype()方法一定会创建新的数组（原始数据的一个拷贝），即使两个类型一致

a=np.ones((2,3,4),dtype=np.int32)
print(a)
#  [[1 1 1 1]
#   [1 1 1 1]
#   [1 1 1 1]]]
# [[[1 1 1 1]
#   [1 1 1 1]
#   [1 1 1 1]]
b=a.astype(np.float32)
print(b)
# [[[1. 1. 1. 1.]
#   [1. 1. 1. 1.]
#   [1. 1. 1. 1.]]
#
#  [[1. 1. 1. 1.]
#   [1. 1. 1. 1.]
#   [1. 1. 1. 1.]]]

a=np.full((2,3,4),25,dtype=np.int32)
print(a)
# [[[25 25 25 25]
#   [25 25 25 25]
#   [25 25 25 25]]
#
#  [[25 25 25 25]
#   [25 25 25 25]
#   [25 25 25 25]]]
print(a.tolist())
[[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]],
 [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]

数组的索引和切片

索引：获取数组中特定位置元素的过程

切片：获取数组元素子集的过程

一维数组的索引和切片：与Python的列表类似

a=np.array([9,8,7,6,5])
print(a[2])
#7
print(a[1:4:2])
#起始编号: 终止编号(不含): 步长，3元素冒号分割
#编号0开始从左递增，或‐1开始从右递减
#[8 6]

多维数组的索引：

a=np.arange(24).reshape((2,3,4))
print(a)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]
print(a[1,2,3])
#每个维度一个索引值，逗号分割
#23

多维数组的切片：

a=np.arange(24).reshape((2,3,4))
print(a)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]
print(a[:,1,-3])
# [ 5 17]
print(a[:,1:3,:])
# [[[ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[16 17 18 19]
#   [20 21 22 23]]]
print(a[:,:,::2])
#每个维度可以使用 步长跳跃切片
# [[[ 0  2]
#   [ 4  6]
#   [ 8 10]]
#
#  [[12 14]
#   [16 18]
#   [20 22]]]

数组与标量之间的运算：数组与标量之间的运算作用于数组的每一个元素

a=np.arange(24).reshape((2,3,4))
print(a)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]
print(a.mean())
#11.5
a =a/a.mean()
print(a)
# [[[0.         0.08695652 0.17391304 0.26086957]
#   [0.34782609 0.43478261 0.52173913 0.60869565]
#   [0.69565217 0.7826087  0.86956522 0.95652174]]
#
#  [[1.04347826 1.13043478 1.2173913  1.30434783]
#   [1.39130435 1.47826087 1.56521739 1.65217391]
#   [1.73913043 1.82608696 1.91304348 2.        ]]]

NumPy一元函数

a=np.arange(24).reshape((2,3,4))
print(a)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]
print(np.square(a))
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]
# [[[  0   1   4   9]
#   [ 16  25  36  49]
#   [ 64  81 100 121]]
#
#  [[144 169 196 225]
#   [256 289 324 361]
#   [400 441 484 529]]]
a=np.sqrt(a)
print(a)
# [[[0.         1.         1.41421356 1.73205081]
#   [2.         2.23606798 2.44948974 2.64575131]
#   [2.82842712 3.         3.16227766 3.31662479]]
#
#  [[3.46410162 3.60555128 3.74165739 3.87298335]
#   [4.         4.12310563 4.24264069 4.35889894]
#   [4.47213595 4.58257569 4.69041576 4.79583152]]]
print(np.modf(a))
# (array([[[0.        , 0.        , 0.41421356, 0.73205081],
#         [0.        , 0.23606798, 0.44948974, 0.64575131],
#         [0.82842712, 0.        , 0.16227766, 0.31662479]],
#
#        [[0.46410162, 0.60555128, 0.74165739, 0.87298335],
#         [0.        , 0.12310563, 0.24264069, 0.35889894],
#         [0.47213595, 0.58257569, 0.69041576, 0.79583152]]]),
# array([[[0., 1., 1., 1.],
#         [2., 2., 2., 2.],
#         [2., 3., 3., 3.]],
#
#        [[3., 3., 3., 3.],
#         [4., 4., 4., 4.],
#         [4., 4., 4., 4.]]]))

NumPy二元函数：

b=np.sqrt(a)
print(b)
# [[[0.         1.         1.41421356 1.73205081]
#   [2.         2.23606798 2.44948974 2.64575131]
#   [2.82842712 3.         3.16227766 3.31662479]]
#
#  [[3.46410162 3.60555128 3.74165739 3.87298335]
#   [4.         4.12310563 4.24264069 4.35889894]
#   [4.47213595 4.58257569 4.69041576 4.79583152]]]
print(np.maximum(a,b))
#运算结果为浮点数
# [[[ 0.  1.  2.  3.]
#   [ 4.  5.  6.  7.]
#   [ 8.  9. 10. 11.]]
#
#  [[12. 13. 14. 15.]
#   [16. 17. 18. 19.]
#   [20. 21. 22. 23.]]]
print(a>b)
# [[[False False  True  True]
#   [ True  True  True  True]
#   [ True  True  True  True]]
# 
#  [[ True  True  True  True]
#   [ True  True  True  True]
#   [ True  True  True  True]]]