python数据分析之Numpy
程序员文章站
2022-06-06 16:05:55
python数据分析之Numpy(三)一、数组的拼接1、竖向拼接vstack()import numpy as npimport matplotlib.pyplot as pltarr1 = np.arange(1,10).reshape(3,3)arr2 = np.arange(10,19).reshape(3,3)print(arr1)#[[1 2 3] [4 5 6] [7 8 9]]print(arr2)#[[10 11 12] [13 14 15] [16 17 18]]a...
python数据分析之Numpy(三)
一、数组的拼接
1、竖向拼接vstack()
import numpy as np
import matplotlib.pyplot as plt
arr1 = np.arange(1,10).reshape(3,3)
arr2 = np.arange(10,19).reshape(3,3)
print(arr1)#[[1 2 3] [4 5 6] [7 8 9]]
print(arr2)#[[10 11 12] [13 14 15] [16 17 18]]
arr3 = np.vstack((arr1,arr2)) #vertically：垂直地
print(arr3)
结果如下：
[
[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]
[13 14 15]
[16 17 18]
]
2、横向拼接hstack()
arr4 = np.hstack((arr1,arr2)) #horizontall：水平的
print(arr4)
结果如下：
[
[ 1 2 3 10 11 12]
[ 4 5 6 13 14 15]
[ 7 8 9 16 17 18]
]
二、数组的行列交换
数组水平或者竖直拼接很简单，但是拼接之前应该注意什么？
竖直拼接的时候：每一列代表的意义相同！！！
如果每一列的意义不同，这个时候应该交换某一组的数的列，让其和另外一类相同
1、行之间的交换
t1 = np.arange(18).reshape(6,3)
print(t1)
结果：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]
[15 16 17]]
t1[[1,3],:] = t1[[3,1],:]
print(t1)
结果：
[[ 0 1 2]
[ 9 10 11]
[ 6 7 8]
[ 3 4 5]
[12 13 14]
[15 16 17]]
2、列之间的交换
t2 = np.arange(18).reshape(3,6)
print(t2)
#[[ 0 1 2 3 4 5]
# [ 6 7 8 9 10 11]
# [12 13 14 15 16 17]]
t2[:,[2,3]] = t2[:,[3,2]]
print(t2)
#[[ 0 1 3 2 4 5]
# [ 6 7 9 8 10 11]
# [12 13 15 14 16 17]]
三、Numpy更多的方法
1、获取最大值最小值的位置
np.argmax(t,axis=0)
np.argmin(t,axis=1)
a1 = np.array([[ 20., 1., 22., 3., 4., 50.],
[ 6., 7., 5, 9., 10., 11.],
[ 12., 13., 14., 20, 16., 17.],
[ 18., 19., 20., 21., 22., 23.]])
max_index = np.argmax(a1,axis = 0)#找到每列的最大值位置
print(max_index)#[0 3 0 3 3 0]
min_index = np.argmin(a1,axis = 1)#找到每行最大值的位置
print(min_index)#[1 2 0 0]
2、创建一个全0的数组
a2 = np.zeros((2,3))
print(a2)#[[0. 0. 0.] [0. 0. 0.]]
3、创建一个全1的数组
a3 = np.ones((3,4))
print(a3)
#[[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]
4、创建一个对角线为1的正方形数组(方阵)
a4 = np.eye(3)
print(a4)
#[[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
四、Numpy生成随机数
在numpy中有一个强大的随机数模块–random它主要有四个部分：
- 生成器：种随机数种子，根据同一种子产生的随机数是相同的
- 简单随机数： 产生简单的随机数据，可以是任何维度
- 分布：产生指定分布的数据，如高斯分布等
- 排列：将所给对象随机排列
1、生成器
电脑是如何产生随机数的：
（1）随机数是由随机种子根据一定的计算方法计算出来的数值。所以，只要计算方法一定，随机种子一定，那么产生的随机数就不会变。
（2）只要用户不设置随机种子，那么在默认情况下随机种子来自系统时钟（即定时/计数器的值）
（3）随机数产生的算法与系统有关，Windows和Linux是不同的，也就是说，即便是随机种子一样，不同系统产生的随机数也不一样。
numpy.random 设置种子的方法有：
| 函数名称 | 函数功能 | 参数说明 |
|---|---|---|
| RandomState | 定义种子类 | RandomState是一个种子类，提供了各种种子方法，最常用seed |
| seed([seed]) | 定义全局种子 | 参数为整数或者矩阵 |
np.random.seed(1) #设置随机种子为1
arr1 = np.random.rand(2,3)
np.random.seed(1234)
arr2 = np.random.rand(2,3)
print(arr1) #[[0.19151945 0.62210877 0.43772774 [0.78535858 0.77997581 0.27259261]]
print(arr2) #[[0.19151945 0.62210877 0.43772774] [0.78535858 0.77997581 0.27259261]]
2、简单随机数
| 函数名称 | 函数功能 | 参数说明 |
|---|---|---|
| rand(d0, d1, …, dn) | 产生均匀分布的随机数 | dn为第n维数据的维度 |
| randn(d0, d1, …, dn) | 产生标准正态分布随机数 | dn为第n维数据的维度 |
| randint(low, high, size, dtype) | 产生随机整数 | low：最小值；high：最大值；size：数据个数 |
| random_sample([size]) | 在[0,1）内产生随机数 | size：随机数的shape，可以为元祖或者列表，[2,3]表示2维随机数，维度为（2,3） |
| random([size]) | 同random_sample([size]) | 同random_sample([size]) |
| ranf([size]) | 同上 | 同上 |
| sample([size])) | 同上 | 同上 |
| np.random.choice(a, size=None, replace=True, p=None) | 从一维array a 或 int 数字a 中，以概率p随机选取大小为size的数据 | replace表示是否重用元素，即抽取出来的数据是否放回原数组中，默认为true（抽取出来的数据有重复） |
| bytes(length) | 返回随机位 | length：位的长度 |
#1、产生2行3列均匀分布的随机数组
a1 = np.random.rand(2,3)
print("a1:",a1)#a1:[[0.27646426 0.80187218 0.95813935] [0.87593263 0.35781727 0.50099513]]
#2、产生2行3列的正太分布随机数组
a2 = np.random.randn(2,3)
print("a2:",a2)#a2:[[ 1.15003572 0.99194602 0.95332413] [-2.02125482 -0.33407737 0.00211836]]
#3、产生一个[-10,10)之间2行3列的随机整数数组
a3 = np.random.randint(-10,10,[2,3],dtype="int")
print("a3:",a3)#a3:[[ -8 -4 -7] [ -3 1 -10]]
#4、产生2[0,1)之间的2行3列浮点型随机数组
a4 = np.random.random([2,3])
print("a4:",a4) #a4:[[0.88922613 0.9871393 0.11744339] [0.39378235 0.45272981 0.53814784]]
3、分布
| 函数名称 | 函数功能 | 参数说明 |
|---|---|---|
| beta(a, b[, size]) | 贝塔分布样本，在 [0, 1]内。 | |
| binomial(n, p[, size]) | 二项分布的样本。 | |
| chisquare(df[, size]) | 卡方分布样本。 | |
| dirichlet(alpha[, size]) | 狄利克雷分布样本。 | |
| exponential([scale, size]) | 指数分布 | |
| f(dfnum, dfden[, size]) | F分布样本。 | |
| gamma(shape[, scale, size]) | 伽马分布 | |
| geometric(p[, size]) | 几何分布 | |
| gumbel([loc, scale, size]) | 耿贝尔分布。 | |
| hypergeometric(ngood, nbad, nsample[, size]) | 超几何分布样本。 | |
| laplace([loc, scale, size]) | 拉普拉斯或双指数分布样本 | |
| logistic([loc, scale, size]) | Logistic分布样本 | |
| lognormal([mean, sigma, size]) | 对数正态分布 | |
| logseries(p[, size]) | 对数级数分布。 | |
| multinomial(n, pvals[, size]) | 多项分布 | |
| multivariate_normal(mean, cov[, size]) | 多元正态分布。 | |
| negative_binomial(n, p[, size]) | 负二项分布 | |
| noncentral_chisquare(df, nonc[, size]) | 非中心卡方分布 | |
| noncentral_f(dfnum, dfden, nonc[, size]) | 非中心F分布 | |
| normal([loc, scale, size]) | 正态(高斯)分布 | |
| pareto(a[, size]) | 帕累托（Lomax）分布 | |
| poisson([lam, size]) | 泊松分布 | |
| power(a[, size]) | Draws samples in [0, 1] from a power distribution with positive exponent a - 1. | |
| rayleigh([scale, size]) | Rayleigh 分布 | |
| standard_cauchy([size]) | 标准柯西分布 | |
| standard_exponential([size]) | 标准的指数分布 | |
| standard_gamma(shape[, size]) | 标准伽马分布 | |
| standard_normal([size]) | 标准正态分布 (mean=0, stdev=1). | |
| standard_t(df[, size]) | Standard Student’s t distribution with df degrees of freedom. | |
| triangular(left, mode, right[, size]) | 三角形分布 | |
| uniform([low, high, size]) | 均匀分布 | |
| vonmises(mu, kappa[, size]) | von Mises分布 | |
| wald(mean, scale[, size]) | 瓦尔德（逆高斯）分布 | |
| weibull(a[, size]) | Weibull 分布 | |
| zipf(a[, size]) | 齐普夫分布 |
#(1)正态分布
mu = 3 #期望为1
sigma = 3 #标准差为3
num = 100000 #个数为100000
rand_data = np.random.normal(mu, sigma, num)
print(rand_data)
count, bins, ignored = plt.hist(rand_data, 30, normed=True)
plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *np.exp( - (bins - mu)**2 / (2 * sigma**2)), linewidth=2, color='r')
plt.show()
正太分布图：
4、排列
| 函数名称 | 函数功能 | 参数说明 |
|---|---|---|
| shuffle(x) | 打乱对象x（多维矩阵按照第一维打乱） | 矩阵或者列表 |
| permutation(x) | 打乱并返回该对象（多维矩阵按照第一维打乱） | 整数或者矩阵 |
data = np.random.randint(1, 6, (2,3))
print(data) #[[4 1 2] [2 4 2]]
np.random.shuffle(data)
print(data) #[[2 4 2] [4 1 2]]
五、Numpy中赋值、视图、深复制
1、赋值
当对numpy数组进行赋值时，只是对同一个对象新建了一个引用，并不是建立新的对象，
所以赋值前后的变量完全是同一对象，对其中一个引用修改时，所有引用都会生效
a = np.arange(5)
b = a # 赋值
print(a is b) #True
2、视图（切片、浅复制）
numpy中允许不同数组间共享数据，这种机制在numpy中称为视图，
对numpy数组的切片和浅复制都是通过视图实现的。如果数组B是数组A的视图(view)，
则称A为B的base(除非A也是视图)。视图数组中的数据实际上保存在base数组中。
a = np.arange(6)
b = a.view() #使用视图
print(a is b) #False
b = b.reshape((2,3))#改变视图的形状
print(a) #[0 1 2 3 4 5]
print(b) #[[0 1 2] [3 4 5]]
#可见改变视图形状不会影响base
b = a.view()
b[b>3] = 3 #改变b的数值
print(a)#[0 1 2 3 3 3]
print(b)#[0 1 2 3 3 3]
#可见改变视图数据会影响base，所以他们是共享数据的
#切片
a = np.arange(12).reshape(3,4)
b = a[:]
print(a is b)#False
#改变b的形状
b = b.reshape(2,6)
print(a)#[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
print(b)#[[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]]
#改变b的数值
b = a[:]
b[b>10] = 10
print(a)#[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 10]]
print(b)#[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 10]]
#切片效果与视图一致,其实切片就是视图
3、深复制
深复制通过数组自带的copy()方法实现，深复制产生的数组与原数组时完全不同的两个数组对象，
完全享有独立的内存空间，所有操作都不会相互影响。
c = np.arange(12).reshape(3,4)
d = c.copy()
print(c is d) #False
c = c.reshape(2,6)#改变c的形状
print(c)#[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
print(d)#[[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]]
d[d>7]=7
print(c) #[[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]]
print(d)#[[0 1 2 3] [4 5 6 7] [7 7 7 7]]
象，
完全享有独立的内存空间，所有操作都不会相互影响。
c = np.arange(12).reshape(3,4)
d = c.copy()
print(c is d) #False
c = c.reshape(2,6)#改变c的形状
print(c)#[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
print(d)#[[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]]
d[d>7]=7
print(c) #[[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]]
print(d)#[[0 1 2 3] [4 5 6 7] [7 7 7 7]]
本文地址：https://blog.csdn.net/qq_42755939/article/details/107091694