标题数据分析与可视化(三)
numpy pandas比较重要 东西多 下一次把 这个细节好多啊 但常用的也不太多 而且可以在用的时候找的 不过还是知道些 会一点的好
这是实例
python提供了众多可以支持数据处理的包,因而利用python进行数据分析非常简洁高效,是进行数据分析的不二之选。其中Numpy和Pandas是最为常用的包。
Numpy简介
NumPy是Python的一种开源的数值计算扩展库。它包含很多功能,如创建n维数组(矩阵)、对数组进行函数运算、数值积分等。 NumPy的诞生弥补了这些缺陷,它提供了两种基本的对象:
ndarray:是储存单一数据类型的多维数组。
ufunc:是一种能够对数组进行处理的函数。
NumPy常用的导入格式:import numpy as np
创建数组
#导包,创建数组
import numpy as np
data1 = [1,4,7,9]#列表
arr1 = np.array(data1)#ndarray数组
print('arr1:',arr1)
data2 = (1,3,5,8)#元组
arr2 = np.array(data2)
print('arr2:',arr2)
data3 = [[1,2,3],[2,4,6],[4,6,7]]#多维数组
arr3 = np.array(data3)
print('arr3:',arr3)
arr1: [1 4 7 9]
arr2: [1 3 5 8]
arr3: [[1 2 3]
[2 4 6]
[4 6 7]]
#array函数中指定数据类型
arr4 = np.array([1,2,3],dtype="float64")
print(arr4.dtype)
float64
#利用arange创建等差一维数组
#格式:np.arange([start, ]stop, [step, ]dtype)
#起始值,默认从0开始;结束值;生成的元素不包括结束值;步长,可省略,默认步长为1;设置元素的数据类型,默认使用输入数据的类型。
arr5 = np.arange(10)
print(arr5)
[0 1 2 3 4 5 6 7 8 9]
#利用arange指定起始,终止,步长,还可设置元素的数据类型
arr6 = np.arange(1,56,10)
print(arr6)
arr7 = np.arange(1,5,1,dtype='int64')
print(arr7)
print(arr7.dtype)
[ 1 11 21 31 41 51]
[1 2 3 4]
int64
#linspace 函数:创建等差一维数组,接收元素数量作为参数
#格式:np.linspace(start, stop, num, endpoint, retstep=False, dtype=None)
#起始值,默认从0开始;结束值;生成的元素不包括结束值;num:要生成的等间隔样例数量
arr7 = np.linspace(0,10,5)
print(arr7)
[ 0. 2.5 5. 7.5 10. ]
#logspace函数:创建等比一维数组
#np.logspace(start, stop, num, endpoint=True, base=10.0, dtype=None))
#start, stop代表的是10的幂,默认基数base为10,第三个参数元素个数。
arr8 = np.logspace(0,10,5)
print(arr8)
[ 1.00000000e+00 3.16227766e+02 1.00000000e+05 3.16227766e+07
1.00000000e+10]
#numpy多维数组
#zeros函数:创建指定长度或形状的全0数组
#格式:np.zeros(shape, dtype=float, order='C')
print("一维数组:",np.zeros(4))
print("二维数组:",'\n',np.zeros([3,3]))
#ones函数:创建指定长度或形状的全1数组
#格式:np. ones(shape, dtype=None, order='C')
print("一维数组:",'\n',np.ones(5))
print("二维数组:",'\n',np.ones([5,3]))
#diag函数:创建一个对角阵。
#格式:np.diag(v, k=0) v是对角线的值
print('对角矩阵:','\n',np.diag([1,2,3]))
一维数组: [ 0. 0. 0. 0.]
二维数组:
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
一维数组:
[ 1. 1. 1. 1. 1.]
二维数组:
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
对角矩阵:
[[1 0 0]
[0 2 0]
[0 0 3]]
nadrry对象属性的说明
#各种属性
data = [
[1,2,3,4],
[4,5,6,7],
[7,8,9,8]
]
arr = np.array(data)
print(arr.dtype)#数据类型
print(arr.shape)#几维数组
print(arr.size)#共有多少个元素
print(arr.ndim)#数组的轴也叫做秩
print(arr.itemsize)#返回数组中每个元素的字节大小
int32
(3, 4)
12
2
4
#设置shape属性,改编维度
arr.shape = 4,3
print(arr)
[[1 2 3]
[4 4 5]
[6 7 7]
[8 9 8]]
#类型转换
arr1 = arr.astype('float64')
print(arr1)
[[ 1. 2. 3.]
[ 4. 4. 5.]
[ 6. 7. 7.]
[ 8. 9. 8.]]
随机数
在NumPy.random模块中,提供了多种随机数的生成函数。如randint函数生成指定范围的随机整数来构成指定形状的数组。 用法: np.random.randint(low, high = None, size = None) 这一块不常用 东西挺多自己可以查一下 这里就只放常用的*
#随机数
arr = np.random.randint(10,100,size=(2,3))
print(arr)
#生成0-1之间的随机数
arr1 = np.random.rand(5)
print(arr1)
arr2 = np.random.rand(4,2)
print(arr2)
[[49 85 42]
[58 69 50]]
[ 0.89068746 0.74976019 0.99101235 0.02050317 0.29849813]
[[ 0.4670391 0.44648257]
[ 0.00910737 0.64454621]
[ 0.99731202 0.32212869]
[ 0.68792601 0.01859019]]
改变数组维度
1* 8 -> 4 * 2 数组重塑: reshape的参数中的其中一个可以设置为-1,表示数组的维度可以通过数据本身来推断。 与reshape相反的方法是数据散开(ravel)或数据扁平化(flatten)。
arr = np.arange(8)
print(arr)
arr1 = arr.reshape(4,2)#注意 不能随便改 行列乘积要相等
print(arr1)
[0 1 2 3 4 5 6 7]
[[0 1]
[2 3]
[4 5]
[6 7]]
arr = np.arange(8)
print(arr)
arr1 = arr.reshape(2,-1)#注意 不能随便改 行列乘积要相等
print('改变之后:','\n',arr1)
[0 1 2 3 4 5 6 7]
改变之后:
[[0 1 2 3]
[4 5 6 7]]
arr = np.arange(10).reshape(5,2)
print('arr:','\n',arr)
arr1 = arr.ravel()
print('数据散开:',arr1)
arr:
[[0 1]
[2 3]
[4 5]
[6 7]
[8 9]]
数据散开: [0 1 2 3 4 5 6 7 8 9]
数组合并:
【only看一下concatenate函数】 hstack函数:实现横向合并 vstack函数:实现纵向组合是利用vstack将数组纵向合并; concatenate函数:可以实现数组的横向或纵向合并,参数axis=1时进行横向合并,axis=0时进行纵向合并。
arr = np.arange(10).reshape(5,2)
arr_ = arr * 2#给里面的每个元素乘以2
print(arr)
print(arr_)
arr1 = np.concatenate((arr,arr_),axis=0)
print('axis=0纵向合并:','\n',arr1)
arr2 = np.concatenate((arr,arr_),axis=1)
print('axis=1横向合并:','\n',arr2)
[[0 1]
[2 3]
[4 5]
[6 7]
[8 9]]
[[ 0 2]
[ 4 6]
[ 8 10]
[12 14]
[16 18]]
axis=0纵向合并:
[[ 0 1]
[ 2 3]
[ 4 5]
[ 6 7]
[ 8 9]
[ 0 2]
[ 4 6]
[ 8 10]
[12 14]
[16 18]]
axis=1横向合并:
[[ 0 1 0 2]
[ 2 3 4 6]
[ 4 5 8 10]
[ 6 7 12 14]
[ 8 9 16 18]]
数组分割:
【only看split函数】 与数组合并相反,hsplit函数、vsplit函数和split函数分别实现数组的横向、纵向和指定方向的分割。 与array_split的差别:split必须要均等分,否则会报错。array_split不会
arr = np.arange(16).reshape(4,4)
print('横向分割为:\n',np.hsplit(arr,2))
print('纵向组合为:\n',np.vsplit(arr,2))
print('asix=0纵向分割:',np.split(arr1,2,axis=0))
print('asix=1横向分割:',np.split(arr2,2,axis=1))
横向分割为:
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
纵向组合为:
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
asix=0纵向分割: [array([[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9]]), array([[ 0, 2],
[ 4, 6],
[ 8, 10],
[12, 14],
[16, 18]])]
asix=1横向分割: [array([[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9]]), array([[ 0, 2],
[ 4, 6],
[ 8, 10],
[12, 14],
[16, 18]])]
数组转置和轴对换
数组转置是数组重塑的一种特殊形式,可以通过transpose方法进行转置。 数组的轴对换swapaxes()。
arr = np.arange(12).reshape(3,4)
print('arr:','\n',arr)
print('arr改变维度后:','\n',arr.reshape(4,3))#改变维度
arr1 = arr.transpose()
print('转置后','\n',arr1)
print('利用T属性转置:','\n',arr.T)
print('数组的轴对换:','\n',arr.swapaxes(1,0))
arr:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
arr改变维度后:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
转置后
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
利用T属性转置:
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
数组的轴对换:
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
一维数组的切片与索引
:一维数组的索引类似Python中的列表! 数组的切片返回的是原始数组的视图,不会产生新的数据,如果需要的并非视图而是要复制数据,则可以通过copy方法实现!
arr = np.arange(12)
print(arr)
print(arr[0])#取第一个
print(arr[-1])#取第二个
print(arr[0:4:1])#取[0,4),步长或者间隔为1
arr1 = arr[0:-1:2].copy()
print('copy后之后的:','\n',arr1)
[ 0 1 2 3 4 5 6 7 8 9 10 11]
0
11
[0 1 2 3]
copy后之后的:
[ 0 2 4 6 8 10]
多维数组的切片与索引:
【这一块可是很重要的,千万千万要搞清楚,别弄混了。hxd,加油。】 对于多维数组,它的每一个维度都有一个索引,各个维度的索引之间用逗号分隔。 也可以使用整数函数和布尔值索引访问多维数组。
#多维数组的索引
arr = np.arange(12).reshape(3,4)
print(arr)
print(arr[0,1:3]) #索引第0行中第1列到第2列的元素
print(arr[:,2]) #所有行的第二列元素
print(arr[:1,:1]) #第0行第0列元素 【行索引,列索引】
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[1 2]
[ 2 6 10]
[[0]]
arr = np.arange(12).reshape(3,4)
#从两个序列的对应位置取出两个整数来组成下标:arr[0,1],arr[1,3]
print(arr)
print('索引结果1:',arr[(0,1),(1,3)])
#索引第1、2行中第0、2、3列的元素
print('索引结果2:',arr[1:2,(0,2,3)])
mask = np.array([1,0,1],dtype = np.bool)
#mask是一个布尔数组,它索引第0,2行中第1列元素
print('索引结果3:',arr[mask,1])
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
索引结果1: [1 7]
索引结果2: [[4 6 7]]
索引结果3: [1 9]
数组与标量间的运算
:数组之所以很强大是因为不需要通过循环就可以完成批量计算! ufunc函数全称为通用函数,是一种能够对数组中的所有元素进行操作的函数。对一个数组进行重复运算时,使用ufunc函数比使用math库中的函数效率要高很多。 常用的ufunc函数运算有四则运算、比较运算和逻辑运算。
1)四则运算:
加(+)、减(-)、乘(*)、除(/)、幂(**)。数组间的四则运算表示对每个数组中的元素分别进行四则运算,所以形状必须相同。
2)比较运算:
>、<、==、>=、<=、!=。比较运算返回的结果是一个布尔数组,每个元素为每个数组对应元素的比较结果。
广播(broadcasting)是指不同形状的数组之间执行算术运算的方式。需要遵循4个原则:【**重要啊啊啊啊啊啊】
1)让所有输入数组都向其中shape最长的数组看齐,shape中不足的部分都通过在左边加1补齐。
2)如果两个数组的形状在任何一个维度上都不匹配,那么数组的形状会沿着维度为1的维度进行扩展,以匹配另一个数组的形状。
3)输出数组的shape是输入数组shape的各个轴上的最大值。
4)如果两个数组的形状在任何一个维度上都不匹配,并且没有任何一个维度等于1,则引发异常
#数组元素的追加
a = [1,2,3]
b = np.array([1,2,3])
b_a = np.append(b,a)
print('把a追加给b:','\n',b_a)
c = b * 2
print('b乘以2:','\n',c)
把a追加给b:
[1 2 3 1 2 3]
b乘以2:
[2 4 6]
#数组的四则运算
a = np.array([1,2,3])
b = np.array([2,4,6])
print('相加:',a+b)
print('相减:',a-b)
print('相乘:',a*b)
print('幂运算:',a**b)
相加: [3 6 9]
相减: [-1 -2 -3]
相乘: [ 2 8 18]
幂运算: [ 1 16 729]
#数组的比较运算
x = np.array([1,3,6])
y = np.array([2,3,4])
print('比较结果(<):',x<y)
print('比较结果(>):',x>y)
print('比较结果(==):',x==y)
print('比较结果(>=):',x>=y)
print('比较结果(!=):',x!=y)
比较结果(<): [ True False False]
比较结果(>): [False False True]
比较结果(==): [False True False]
比较结果(>=): [False True True]
比较结果(!=): [ True False True]
#ufunc函数的广播:指不同形状的数组之间的运算**比较重要 一定要掌握
arr1 = np.array([[0,0,0],[1,1,1],[2,2,2]])
arr2 = np.array([1,2,3])
print('arr1:\n',arr1)
print('arr2:\n',arr2)
print('arr1+arr2:\n',arr1+arr2)
arr1:
[[0 0 0]
[1 1 1]
[2 2 2]]
arr2:
[1 2 3]
arr1+arr2:
[[1 2 3]
[2 3 4]
[3 4 5]]
a = np.arange(1, 13).reshape(4, 3) #最好自己在本子上花花 实在不会私信问我 我可以给你画图说
b = np.arange(1,5).reshape(4,1)
print(a)
print(b)
print(a+b)
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
[[1]
[2]
[3]
[4]]
[[ 2 3 4]
[ 6 7 8]
[10 11 12]
[14 15 16]]
条件逻辑运算
利用基本的逻辑运算就可以实现数组的条件运算。 这种方法对大规模数组处理效率不高,也无法用于多维数组。NumPy提供的where方法可以克服这些问题。
#这一块我也不怎么片的来
where的用法:
np.where(condition, x, y)
满足条件(condition),输出x,不满足则输出y。
where中若只有条件 (condition),没有x和y,则输出满足条件元素的坐标。这里的坐标以tuple的形式给出,通常原数组有多少维,输出的tuple中就包含几个数组,分别对应符合条件元素的各维坐标。
numpy.where函数是三元表达式x if condition else y的矢量化版本。假设我们有一个布尔数组和两个值数组。
xarr = np.array([1.1,1.2,1.3,1.4,1.5])
yarr = np.array([2.1,2.2,2.3,2.4,2.5])
cond = np.array([True,False,True,True,False])
假设我们想要根据cond中的值选取xarr和yarr的值:当cond中的值为true时,选取xarr的值,否则从yarr中选取。列表推导式的写法应该如下所示:
result = [(x if c else y) for x,y,c in zip(xarr,yarr,cond)]
print result
输出结果:
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]
但是这样有几个问题。
一、它对大数组的处理速度不是很快
二、它无法用于多维数组。 若使用np.where,则可以将该功能写的特别简洁:
result = np.where(cond,xarr,yarr)
print result
输出结果
[ 1.1 2.2 1.3 1.4 2.5]
np.where第二个和第三个参数不必是数组,也可以是标量。
如下为随机数据组成的矩阵,将所有正值替换为2,所有负值替换为-2
arr = np.random.randn(4,4)
print arr
print np.where(arr>0,2,-2)
输出结果
[[ 1.80262171 0.7143772 2.28177789 0.43296688]
[-0.71345291 0.70720256 0.09209334 -1.12625402]
[ 1.45065299 0.55110371 -0.659351 -0.41175648]
[ 0.4328763 0.67499992 -0.53531592 -0.38604227]]
[[ 2 2 2 2]
[-2 2 2 -2]
[ 2 2 -2 -2]
[ 2 2 -2 -2]]
只将正值设置为2
print np.where(arr>0,2,arr)
输出结果
[[-1.05460459 2. 2. 2. ]
[ 2. 2. 2. 2. ]
[-0.52191645 -0.98692719 2. 2. ]
[-2.11448246 2. -0.25533101 -1.07167209]]
还可以用where实现更复杂的逻辑
比如
np.where(cond1&cond2,0,
np.where(cond1,1,
np.where(cond2,2,3)))
等价于
result = []
for i in range(n):
if cond1[i] and cond2[i]:
result.append(0)
elif cond1[i]:
result.append(1)
elif cond2[i]:
result.append(2)
else:
result.append(3)
arr1 = np.array([1,3,5,7])
arr2 = np.array([2,4,6,8])
cond = np.array([True,False,True,False])
result = [(x if c else y)for x,y,c in zip(arr1,arr2,cond)]
result
[1, 4, 5, 8]
np.where([[True,False], [True,True]],[[1,2], [3,4]],[[9,8], [7,6]])#where的基本用法
array([[1, 8],
[3, 4]])
w = np.array([2,5,6,3,10])
np.where(w>4)
#where只有condition参数
(array([1, 2, 4], dtype=int64),)
cond1 = np.array([True,False,True,True])
cond2 = np.array([True,False,False,True])
result = []
for i in range(4):
if cond1[i] and cond2[i]:
result.append(0)
elif cond1[i]:
result.append(1)
elif cond2[i]:
result.append(2)
else:
result.append(3)
print(result)
np.where (cond1&cond2,0,
np.where(cond1,1,
np.where(cond2,2
,3)))#返回元组
[0, 3, 1, 0] array([0, 3, 1, 0])
NumPy提供了多种文件操作函数存取数组内
文件存取的格式分为两类:二进制和文本。而二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。
NumPy中读写二进制文件的方法有:
1. np.load(“文件名.npy")是从二进制文件中读取数据;
2. np.save(“文件名[.npy]", arr) 是以二进制格式保存数据。
NumPy中读写文本文件的主要方法有:
1. np.loadtxt("../tmp/arr.txt",delimiter = ",")把文件加载到一个二维数组中;
2. np.savetxt("../tmp/arr.txt", arr, fmt = "%d", delimiter = ",")是将数组写到某种分隔符隔开的文本文件中;
3. np.genfromtxt("../tmp/arr.txt", delimiter = ",")是结构化数组和缺失数据。
#二进制文件的读写
a = np.arange(1,13).reshape(3,4)
print('数组a:','\n',a)
np.save('a.npy',a)
c = np.load('a.npy')
print('读出来的a:','\n',c)
数组a:
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
读出来的a:
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
#二进制文件多个数组保存
a = np.array([[1,2,3],[6,7,8]])
b = np.arange(0,1,0.1)
c = np.sin(b)
np.savez('sumfile.npz',a,b,c)
r = np.load('sumfile.npz')
r['arr_1']#去文件中的第二个数组
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
#文本文件的读写
a = np.arange(0,12,0.5).reshape(4,-1)
print('a数组:',a)
np.savetxt('a1.txt',a)#默认保存数值按‘%。18e’
a1_out = np.loadtxt('a1.txt')
np.savetxt('a2.txt',a,fmt='%d',delimiter=',')#按整数保存数值,用逗号隔开
a2_out = np.loadtxt('a2.txt',delimiter = ',')#读取的时候也要按逗号读取,不然会报错
print('默认保存的;',a1_out)
print('整数保存的:',a2_out)
a数组: [[ 0. 0.5 1. 1.5 2. 2.5]
[ 3. 3.5 4. 4.5 5. 5.5]
[ 6. 6.5 7. 7.5 8. 8.5]
[ 9. 9.5 10. 10.5 11. 11.5]]
默认保存的; [[ 0. 0.5 1. 1.5 2. 2.5]
[ 3. 3.5 4. 4.5 5. 5.5]
[ 6. 6.5 7. 7.5 8. 8.5]
[ 9. 9.5 10. 10.5 11. 11.5]]
整数保存的: [[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
排序 重复和去重 统计:
排序
1.sort函数对数据直接进行排序,调用改变原始数组,无返回值。
格式:
numpy.sort(a, axis, kind, order) :排序数组,排序算法,排序字段名,axis=0列,1为纵
2.np.argsort函数和np.lexsort函数根据一个或多个键值对数据集进行排序。
np.argsort(): 返回的是数组值从小到大的索引值;
np.lexsort(): 返回值是按照最后一个传入数据排序的结果。
使用argsort和lexsort函数,可以在给定一个或多个键时,得到一个由整数构成的索引数组,索引值表示数据在新的序列中的位置。
去重和重复
1.在NumPy中,对于一维数组或者列表,unique函数去除其中重复的元素,并按元素由大到小返回一个新的元组或者列表。
2.统计分析中有时也需要把一个数据重复若干次,使用tile和repeat函数即可实现此功能。
tile函数的格式:np.tile(A, reps)
其中,参数A表示要重复的数组,reps表示重复次数。
repeat函数的格式:np.repeat(A, reps, axis = None)
“a”: 是需要重复的数组元素,
“repeats”: 是重复次数,
“axis”: 指定沿着哪个轴进行重复,axis = 0表示按行进行元素重复;axis = 1表示按列进行元素重复。
统计分析
NumPy中提供了很多用于统计分析的函数,常见的有sum、mean、std、var、min和max等。
几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。
axis=0时表示沿着纵轴进行计算,axis=1时沿横轴进行计算。
例子:
arr = np.array([7,9,5,2,9,4,3,1,4,3])
print('原数组:',arr)
arr.sort()
print('排序后:',arr)#sort一维数组排序
原数组: [7 9 5 2 9 4 3 1 4 3]
排序后: [1 2 3 3 4 4 5 7 9 9]
arr1 = np.array([[1,3,2],[5,1,3]])
print(arr1)
print(np.sort("按列",arr1,axis=0))
print(np.sort("按行",arr1,axis=1))
[[1 3 2]
[5 1 3]]
[[1 1 2]
[5 3 3]]
[[1 2 3]
[1 3 5]]
arr = np.array([7,9,5,2,9,4,3,1,4,3])
print('原数组:',arr)
print('排序后:',arr.argsort())
#返回值为数组排序后的下标排列
原数组: [7 9 5 2 9 4 3 1 4 3]
排序后: [7 3 6 9 5 8 2 0 1 4]
a = np.array([7,2,1,4])
b = np.array([5,2,6,7])
c = np.array([5,2,4,6])
d = np.lexsort((a,b,c))
print(d)
print('排序后:',list(zip(a[d],b[d],c[d])))
[1 2 0 3]
排序后: [(2, 2, 2), (1, 6, 4), (7, 5, 5), (4, 7, 6)]
names = np.array(['红色','蓝色','黄色','白色','红色'])
print('原数组:',names)
print('去重后的数组:',np.unique(names)) ##去重
原数组: ['红色' '蓝色' '黄色' '白色' '红色']
去重后的数组: ['白色' '红色' '蓝色' '黄色']
arr = np.arange(5)
print('原数组:',arr)
wy = np.tile(arr,3)
print('重复数据处理:\n',wy)##重复数据
原数组: [0 1 2 3 4]
重复数据处理:
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
arr = np.arange(5)
print('原数组:',arr)
wy = np.tile(arr,3)
print('重复数据处理:\n',wy)
arr2 = np.array([[1,2,3],[4,5,6]])
print('重复数据处理:\n',arr2.repeat(2,axis=0))
原数组: [0 1 2 3 4]
重复数据处理:
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
重复数据处理:
[[1 2 3]
[1 2 3]
[4 5 6]
[4 5 6]]
arr = np.arange(20).reshape(4,5)
print('创建的数组:\n',arr)
print('数组的和:',np.sum(arr))
print('数组纵轴的和:',np.sum(arr,axis = 0))
print('数组横轴的和:',np.sum(arr,axis = 1))
print('数组的均值:',np.mean(arr))
print('数组横轴的均值:',np.mean(arr,axis = 1))
print('数组的标准差:',np.std(arr))
print('数组横轴的标准差:',np.std(arr,axis = 1))
创建的数组:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
数组的和: 190
数组纵轴的和: [30 34 38 42 46]
数组横轴的和: [10 35 60 85]
数组的均值: 9.5
数组横轴的均值: [ 2. 7. 12. 17.]
数组的标准差: 5.76628129734
数组横轴的标准差: [ 1.41421356 1.41421356 1.41421356 1.41421356]