Python数据分析之Numpy入门

目录

• 1、什么是numpy
• 2、安装numpy
• 3、n维数组对象
• 4、数组创建
• 5、数组维度
• 6、数组元素个数
• 7、数组元素数据类型
• 8、改变数组形状
• 9、数组索引和切片操作
• 10、数组转换与元素迭代
• 11、数组级联操作
• 12、数组数值舍入
• 13、数组数值添加
• 14、数组元素去重
• 15、常用数学函数
• 16、常用统计函数
• 17、矩阵运算

1、什么是numpy

NumPy(Numerical Python)是Python语言中做科学计算的基础库。重在于数值计算，也是大部分Python科学计算库的基础，多用于在大型，多维数组上执行的数值运算。

numpy具有以下三大特点

• 拥有n维数组对象
• 拥有广播功能
• 拥有各种科学计算API

2、安装numpy

numpy是一个python库，所以使用python包管理工具pip或者conda都可以安装

pip install numpy
或者
conda install numpy

3、n维数组对象

n维数组ndarray对象，是一系列同类数据的集合，可以进行索引、切片、迭代操作。

判断一个数组是几维，主要是看它有几个轴axis
一个轴表示一维数组，两个轴表示二维数组，以此类推。
每个轴都代表一个一维数组。
比如说，二维数组第一个轴里的每个元素都是一个一维数组，也就是第二个轴。

一维数组一个轴：

[1,2,3]

二维数组两个轴：

[[0, 1, 2],
 [3, 4, 5]]

三维数组三个轴：

[[[ 0,  1,  2],
  [ 3,  4,  5]],
 [[ 6,  7,  8],
  [ 9, 10, 11]]]

以此类推n维数组

4、数组创建

numpy中常用array函数创建数组，传入列表或元组即可

• 创建一维数组，并指定数组类型为int

import numpy as np
np.array([1,2,3],dtype=int)

# 输出：array([1, 2, 3])

• 创建二维数组

import numpy as np
np.array(((1,2),(3,4)))

 '''
输出：
array([[1, 2],
       [3, 4]])
'''

• 使用arange函数创建一维数字数组，用法类似python的range函数

import numpy as np
np.arange(1,6)
'''
输出：array([1, 2, 3, 4, 5])
'''

• 创建随机数组，numpy的random模块用来创建随机数组

random.rand函数，生成[0,1)均匀分布的随机数组

import numpy as np
# 创建2行2列取值范围为[0,1)的数组
np.random.rand(2,2)
'''
输出：
array([[0.99449146, 0.92339551],
       [0.1837405 , 0.41719798]])
'''

random.randn函数，生成数值成标准正态分布（平均值为0，标准差为1）的数组

import numpy as np
# 创建2行3列，取值范围为标准正态分布的数组
np.random.randn(3,2)
'''
输出：
array([[-1.27481003, -1.5888111 ],
       [ 0.16985203, -2.91526479],
       [ 1.75992671, -2.81304831]])
'''

random.randint函数，生成可以指定范围的随机整数数组

import numpy as np
# 创建2行2列,取值范围为[2,10)的随机整数数组
np.random.randint(2,10,size=(2,2))
'''
输出：
array([[5, 4],
       [3, 7]])
'''

random.normal函数，生成数值成正态分布（可指定平均值、标准差）的数组

import numpy as np
# 创建一维，数值成正态分布（均值为1，标准差为2）的数组
# 参数loc代表均值，scale代表标准差
np.random.normal(loc=1,scale=2,size=5)
'''
输出：
array([ 0.82962241,  0.41738042,  0.0470862 ,  1.79446076, -1.47514478])
'''

random模块的其他函数

函数	说明
seed	确定随机数生成器的种子，固定生成的随机数
permutation	返回一个序列的随机排列或返回一个随机排列的范围
shuffle	对一个序列就地随机排列
rand	产生均匀分布的样本值
randint	从给定的上下限范围内随机选取整数
randn	产生正态分布（平均值为0，标准差为1）的样本值，类似于MATLAB接口
binomial	产生二项分布的样本值
normal	产生正态（高斯）分布的样本值
beta	产生Beta分布的样本值

5、数组维度

数组维度即代表轴的数量，可以通过数组ndarray对象的ndim或shape属性，来查看轴的数量

• ndim属性直接返回维度值
• shape属性返回一个元组，元组的长度即代表维度值，里面的数字从左往右分别代表每一轴的元素数量

import numpy as np
# 创建一维数组
x1 = np.array([1,2,3])
# 返回维度值
x1.ndim
'''
输出：1
'''
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]])
# 返回形状
x2.shape
'''
输出：(2, 3)
元素长度为2代表二维，
元素2代表0轴有两个元素，
元素3代表1轴有3个元素。
'''

6、数组元素个数

数组ndarray对象的size属性可以查看数组包含元素总数

import numpy as np
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]])
# 查看元素总数
x2.size
'''
输出：6
'''

通过shape属性返回元素的乘积，来计算数组元素数量

import numpy as np
from functools import reduce
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]])
# 查看元素总数
reduce(lambda x,y:x*y , x2.shape)
'''
输出：6
shape形状：
(2,3)
'''

7、数组元素数据类型

numpy支持的数据类型非常多，所以很适合做数值计算，常见的数据类型如下
来源：https://www.runoob.com/numpy/numpy-dtype.html

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

numpy数组ndarrry对象提供dtype属性，用来查看数组类型

import numpy as np
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]],dtype=int)
# 返回类型
x2.dtype
'''
输出：dtype('int32')
'''

8、改变数组形状

数组的shape属性返回一个元组，能够反映数组的形状，包括维度以及每个轴的元素数量
对于改变数组形状的常用方式有两种

• reshape方法，它返回一个新的数组，而不能改变原始数组

传入整数或者元组形式的参数
传入的参数和shape属性返回的元组的含义是一样的。例如， x2.reshape(1,2,3)是将二维数组转换成三维数组，参数个数代表要转换的维度，参数数字从左到右分别表示0轴、1轴、2轴的元素数量

import numpy as np
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]])
# 将x2转换为三维数组，并且自定义每个轴的元素数量
x2.reshape(1,2,3)
'''
输出：
array([[[1, 2, 3],
        [4, 5, 6]]])
'''

• resize方法，和reshape方法使用形式一样，区别是resize方法改变了原始数组形状

import numpy as np
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]])
# 将x2转换为三维数组，并且自定义每个轴的元素数量
x2.resize((1,2,3))
x2
'''
输出：
array([[[1, 2, 3],
        [4, 5, 6]]])
'''

9、数组索引和切片操作

numpy一维数组的索引和切片操作类似python列表
例如取一维数组前三个元素

import numpy as np
# 创建一维数组
x1 = np.array([1,2,3,4])
# 切片，取前三个元素
x1[:3]
'''
输出：
array([1, 2, 3])
'''

重点是对多维数组的索引和切片操作

• 多维数组索引

多维数组有多个轴，那么就需要对每个轴进行索引。
例如，三维数组形状为(x,y,z)，分别代表：0轴有x个元素、1轴有y个元素，2轴有z个元素。
对0、1、2轴进行索引，如果取o轴第2个元素、1轴第0个元素、2轴第3个元素，那么索引形式就为[2,0,3]

import numpy as np
# 创建三维数组
x3 = np.arange(24).reshape(3,2,4)
# 对该三维数组进行索引
x3[2,0,3]

'''
输出：19

三维数组形式：
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23]]])
'''

• 多维数组切片

如果取o轴前2个元素、1轴前1个元素、2轴后2个元素，那么切片形式就为[:2,:1,-2:]

import numpy as np
# 创建三维数组
x3 = np.arange(24).reshape(3,2,4)
# 对该三维数组进行切片
x3[:2,:1,-2:]

'''
输出：
array([[[ 2,  3]],

       [[10, 11]]])

三维数组形式：
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23]]])
'''

• 数组数据翻转

import numpy as np
# 创建二维数组
arr = np.random.randint(0,100,size=(5,7))
# 对该数组进行数据反转
arr[::-1,::-1]

'''
输出
array([[42, 49, 71, 20, 38, 94, 47],
       [47, 73,  6, 39, 60, 94, 93],
       [94,  2,  5, 18,  4, 18, 78],
       [25, 85, 38, 39, 20,  1, 84],
       [86, 28,  9, 80, 69,  9,  3]])

二维数组形式：
array([[ 3,  9, 69, 80,  9, 28, 86],
       [84,  1, 20, 39, 38, 85, 25],
       [78, 18,  4, 18,  5,  2, 94],
       [93, 94, 60, 39,  6, 73, 47],
       [47, 94, 38, 20, 71, 49, 42]])
'''

10、数组转换与元素迭代

• 数组转换

利用数组对象的ravel方法，可将多维数组展开为一维数组

import numpy as np
# 创建数组
x3 = np.arange(12).reshape(3,4)
# 对该数组进行索引
x3.ravel()
'''
输出：
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
'''

• 元素迭代

说道迭代，最容易想到的是对数组使用for循环进行迭代，其次是使用迭代器
for循环对于一维数组是可以的，对于多维数组，迭代时相对于0轴完成的
如果使用嵌套循环，固然可以，然而太低效
此时使用flat方法可以将多维数组平铺为一维的迭代器

import numpy as np
# 创建二维数组
x2 = np.array([[1,2,3],[4,5,6]])
# 先平铺，再迭代
for i in x2.flat:
    print(i)
'''
输出：
1
2
3
4
5
6
'''

11、数组级联操作

级联是指将两个或多个numpy数组进行横向或者纵向的拼接
拼接时有参数axis，值为0表示按列操作(竖直方向)，值为1时表示按行操作(水平方向)

import numpy as np
# 创建两个二维数组
x1 = np.array([[1,2,3],[4,5,6]])
x2 = np.array([[7,8,9],[10,11,12]])
# 连接,默认沿0轴连接
np.concatenate((x1,x2))

'''
输出：
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
'''

# 指定沿1轴连接
np.concatenate((x1,x2),axis=1)

'''
输出：
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])
'''

12、数组数值舍入

around函数，用于四舍五入，返回一个新数组

import numpy as np
# 创建一维数组
x1 = np.array([1.45,2.78,3.12])
# 四舍五入，到小数点后1位
np.around(x1,1)
'''
输出：
array([1.4, 2.8, 3.1])
'''

floor函数，用于向下取整，返回一个新数组

import numpy as np
# 创建一维数组
x1 = np.array([1.45,2.78,3.12])
# 向下取整
np.floor(x1)
'''
输出：
array([1., 2., 3.])
'''

ceil函数，用于向上取整，返回一个新数组

import numpy as np
# 创建一维数组
x1 = np.array([1.45,2.78,3.12])
# 向下取整
np.ceil(x1)
'''
输出：
array([2., 3., 4.])
'''

13、数组数值添加

• append 函数向数组末尾追加值，可以指定不同的轴

import numpy as np
# 创建一个二维数组
x1 = np.array([[1,2,3],[4,5,6]])
# 直接向数组末尾添加元素，返回平铺的一维数组
np.append(x1,[7,8,9])
'''
输出：
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
'''

# 沿轴 0 添加元素
np.append(x1, [[7,8,9]],axis = 0)
'''
输出：
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
'''

# 沿轴 1 添加元素
np.append(x1, [[5,5,5],[7,8,9]],axis = 1)
'''
输出：
array([[1, 2, 3, 5, 5, 5],
       [4, 5, 6, 7, 8, 9]])
'''

• insert 函数可以沿给定轴，在数组中任意位置插入数据

import numpy as np
# 创建一个二维数组
x1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
# 直接在指定位置插入元素，返回平铺的一维数组
np.insert(x1,2,[0,0,0])
'''
输出：
array([1, 2, 0, 0, 0, 3, 4, 5, 6, 7, 8, 9])

原数组：
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
'''

# 指定位置，沿轴 0 插入元素
np.insert(x1,1,[0,0,0],axis=0)
'''
输出：
array([[1, 2, 3],
       [0, 0, 0],
       [4, 5, 6],
       [7, 8, 9]])
'''

# 指定位置，沿轴 1插入元素
np.insert(x1,2,[0,0,0],axis=1)
'''
输出：
array([[1, 2, 0, 3],
       [4, 5, 0, 6],
       [7, 8, 0, 9]])
'''

14、数组元素去重

unique 函数用于去除数组中的重复元素，返回一个新数组
unique函数还能返回重复元素的索引、计数等信息

import numpy as np
# 创建一个一维数组
x1 = np.array([2,3,5,1,3,8,1,0])
np.unique(x1)
'''
输出：
array([0, 1, 2, 3, 5, 8])
'''

15、常用数学函数

• numpy提供了标准的三角函数：sin()、cos()、tan()
• numpy.around(a,decimals)函数返回指定数字的四舍五入值
  • 参数说明：
    • a:数组
    • decimails:舍入的小数位数，默认值为0，如果为负，整数将四舍五入到小数点左侧的位置

import numpy as np
# 创建一个一维数组
arr = np.random.randint(0,100,size=(3,4))
np.sin(arr)

np.around(arr,decimals=-1)
'''
输出：
array([[-0.24525199, -0.44411267, -0.8462204 , -0.28790332],
       [-0.62988799,  0.10598751,  0.99060736, -0.99388865],
       [-0.7391807 , -0.40403765, -0.91652155,  0.89399666]])

array([[90, 80, 20, 20],
       [80, 90, 10, 80],
       [60, 30, 40, 90]])
'''

16、常用统计函数

• numpy.amin()和numpy.amax(),用于计算数组中的元素沿指定轴的最小，最大值
• numpy.ptp():计算数组中元素最大值与最小值的差(最大值-最小值)
• numpy.median()函数用于计算数组a中元素的中位数（中值）
• 标准差std():标准差是一组数据平均值分散程度的一种度量
  • 公式:std = sqrt(mean((x - x-mean())**2))
  • 如果数组是[1,2,3,4],则其平均值为2.5，因此，差的平方是[2.25,0.25,0.25,2.25],并且其平均值的平方根除以4,即sqrt(5/4),结果为1.1180339887498949
• 方差var():统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即mean((x - x.mean())**2)。换句话说，标准差是方差的平方根

import numpy as np
a = np.array([22,33,21,34,41,44])
a.std()
a.var()

'''
输出：
8.65544144839919

74.91666666666667
'''

17、矩阵运算

• numpy中包含了一个矩阵库numpy.matlib，该模块中的函数返回的是一个矩阵，而不是ndarray对象。一个的矩阵是一个由行(row)列(column)元素排列成的矩形阵列
• numpy.matlib.identity()函数返回给定大小的单位矩阵。单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）的元素均为1，除此以外全都为0
• 转置矩阵.ST

import numpy as np
# 创建二维数组
x1 = np.arange(12).reshape(3,4)
# 转置
x1.T

'''
输出：
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
原数组：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
'''

• 矩阵相乘
  • numpy.dot(a, b, out=None)
    • a : ndarray数组
    • b : ndarray数组
    • 矩阵相乘：第一个矩阵第一行的每个数字（2和1），各自乘以第二个矩阵第一列对应位置的数字（1和1），然后将乘积相加（ 2 x 1 + 1 x 1），得到结果矩阵左上角的那个值3。也就是说，结果矩阵第m行与第n列交叉位置的那个值，等于第一个矩阵第m行与第二个矩阵第n列，对应位置的每个值的乘积之和。

import numpy as np
# 创建二维数组
a1 = np.array([[2,1],[4,3]])
a2 = np.array([[1,2],[1,0]])
np.dot(a1,a2)

'''
输出：
array([[3, 4],
       [7, 8]])
'''

以上就是个人学习数据分析相关的numpy入门及常用知识，欢迎来骚扰O(∩_∩)O