标题数据分析与可视化（三）
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]
1046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
