python--numpy常用属性及方法

• numpy数组对象
• • 创建数组对象
  • 生成随机数
  • 通过索引访问数组
  • 变换数组的形态
• numpy矩阵与通用函数
• • 创建numpy矩阵
  • ufunc函数
• 利用numpy进行统计分析
• • 读/写文件
  • 使用函数进行简单的统计分析
  • 常用的统计函数
  • 鸢尾花长度数据统计分析

1. 数组属性

2. 数组创建
   numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

3. 数组数据类型

• 实例

import numpy as np
arr1 = np.array([1, 2, 3, 4])
print('创建的数组arr1为：', arr1)
arr2 = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])
print('创建的数组arr2为：n', arr2)

创建的数组arr1为： [1 2 3 4]
创建的数组arr2为：
 [[ 1  2  3  4]
 [ 4  5  6  7]
 [ 7  8  9 10]]

print('数组维度为：', arr2.shape)
print('数组类型为：', arr2.dtype)
print('数组元素个数为：', arr2.size)
print('数组每个元素大小为：', arr2.itemsize)

数组维度为： (3, 4)
数组类型为： int32
数组元素个数为： 12
数组每个元素大小为： 4

arr2.shape=4,3
print('重新设置shape后的arr2为：n', arr2)
# 元素的顺序没改变，只改变了每个轴的大小

重新设置shape后的arr2为：
 [[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]

print('使用arange创建的数组为：n', np.arange(0, 1, 0.1))
print('使用linspace创建的数组为：n', np.linspace(0, 1, 12))
# 创建的是等比数列
print('使用logspace创建的数组为：n', np.logspace(0, 2, 20))
# 全部数组为0
print('使用zeros创建的数组为：n', np.zeros((2, 3)))
# 主对角线全为1
print('使用eye创建的数组为：n', np.eye(3))
# 主对角线上的元素
print('使用diag创建的数组为：n', np.diag([1,2,3,4]))
# 全部数组全为1
print('使用ones创建的数组为：n', np.ones((5,3)))

使用arange创建的数组为：
 [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
使用linspace创建的数组为：
 [0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
 0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]
使用logspace创建的数组为：
 [  1.           1.27427499   1.62377674   2.06913808   2.6366509
   3.35981829   4.2813324    5.45559478   6.95192796   8.8586679
  11.28837892  14.38449888  18.32980711  23.35721469  29.76351442
  37.92690191  48.32930239  61.58482111  78.47599704 100.        ]
使用zeros创建的数组为：
 [[0. 0. 0.]
 [0. 0. 0.]]
使用eye创建的数组为：
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
使用diag创建的数组为：
 [[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]
使用ones创建的数组为：
 [[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

# 数组类型转换
print('整型转化为浮点型，转换结果为：', np.float64(42))
print('浮点型转化为整型，转换结果为：', np.int8(42.0))
print('整型转化为布尔型，转换结果为：', np.bool(42))
print('整型转化为布尔型，转换结果为：', np.float64(0))
print('布尔型转化为浮点型，转换结果为：', np.float(True))
print('布尔型转化为浮点型，转换结果为：', np.float(False))

整型转化为浮点型，转换结果为： 42.0
浮点型转化为整型，转换结果为： 42
整型转化为布尔型，转换结果为： True
整型转化为布尔型，转换结果为： 0.0
布尔型转化为浮点型，转换结果为： 1.0
布尔型转化为浮点型，转换结果为： 0.0

# 创建数据类型
df=np.dtype([("name",np.str_,40),("numitems",np.int64),("price",np.float64)])
print('数据类型为：', df)

数据类型为： [('name', ' 
# 查看数据类型
print('数据类型为：', df["name"])
print('数据类型为：', np.dtype(df["name"]))
# 自定义数组数据
itemz=np.array([("tomatoes",42,4.14),("cabbages",13,1.72)],dtype=df)
print('自定义数据为：',itemz)
 
数据类型为：  
生成随机数 
random模块常用随机数生成函数
 
函数
说明
seed
确定随机数生成器的种子
permutaion
返回一个序列的随机排列或返回一个随机排列的范围
shuffle
对一个序列进行随机排列
binomial
产生二项分布的随机数
normal
产生正态分布的随机数
beta
产生beta分布的随机数
chisquare
产生卡方分布的随机数
gamma
产生gamma分布的随机数
uniform
产生在[0,1]中均匀分布的随机数
print('生成的随机数组为：',np.random.random(10))
print('生成均匀分布的随机数组为：n',np.random.rand(2,3))
print('生成服从正态分布的随机数组为：n',np.random.randn(2,3))
print('生成给定上下限的随机数组为：n',np.random.randint(2,10,size=[2,5]))
 
生成的随机数组为： [0.05478456 0.31793173 0.63195643 0.96141967 0.00333223 0.72768221
 0.30489522 0.90413895 0.15791078 0.99559445]
生成均匀分布的随机数组为：
 [[0.66725553 0.44391885 0.95413037]
 [0.77064322 0.53726875 0.26902613]]
生成服从正态分布的随机数组为：
 [[ 0.95840647 -0.51848368  0.68529844]
 [-0.61515571  0.37733786  0.43860996]]
生成给定上下限的随机数组为：
 [[5 5 7 9 4]
 [2 3 5 9 4]]
 
通过索引访问数组 
一维数组的索引–与list索引方法一致
 
arr=np.arange(10)
print('整数作索引，索引结果为：',arr[5])
print('范围作索引，不包括arr[5]，索引结果为：',arr[3:5])
print('省略开始索引作索引，索引结果为：',arr[:5])
print('负数作索引，索引结果为：',arr[-1])
arr[2:4]=100,101
print('下标用来修改元素，数组结果为：',arr)
print('步长作索引，索引结果为：',arr[1:-1:2])
print('步长负数作索引，开始下标必需大于结束下标，索引结果为：',arr[5:1:-2])
 
整数作索引，索引结果为： 5
范围作索引，不包括arr[5]，索引结果为： [3 4]
省略开始索引作索引，索引结果为： [0 1 2 3 4]
负数作索引，索引结果为： 9
下标用来修改元素，数组结果为： [  0   1 100 101   4   5   6   7   8   9]
步长作索引，索引结果为： [  1 101   5   7]
步长负数作索引，开始下标必需大于结束下标，索引结果为： [  5 101]
 
多维数组的索引–每一个维度都有一个索引，各个维度的索引之间用逗号隔开
 
arr=np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
print('创建的二维数组为：n',arr)
print('索引第0行中第3列和4列的元素，索引结果为：n',arr[0,3:5])
print('索引第2和3行中第3~5列的元素，索引结果为：n',arr[1:,2:])
print('索引第2列的元素，索引结果为：',arr[:,2])
print('从两个序列的对应位置取出两个整数来组成下标，索引结果为：',arr[[(0,1,2),(1,2,3)]])
print('索引第2、3行中第0、2、3列的元素，索引结果为：n',arr[1:,(0,2,3)])
mask=np.array([1,0,1],dtype=np.bool)
print('mask是一个布尔数组，索引第1、3行中第2列的元素，索引结果为：',arr[mask,2])
 
创建的二维数组为：
 [[ 1  2  3  4  5]
 [ 4  5  6  7  8]
 [ 7  8  9 10 11]]
索引第0行中第3列和4列的元素，索引结果为：
 [4 5]
索引第2和3行中第3~5列的元素，索引结果为：
 [[ 6  7  8]
 [ 9 10 11]]
索引第2列的元素，索引结果为： [3 6 9]
从两个序列的对应位置取出两个整数来组成下标，索引结果为： [ 2  6 10]
索引第2、3行中第0、2、3列的元素，索引结果为：
 [[ 4  6  7]
 [ 7  9 10]]
mask是一个布尔数组，索引第1、3行中第2列的元素，索引结果为： [3 9]
 
变换数组的形态 
改变数组形状实例
 
arr=np.arange(12)
print('创建的一维数组为：n',arr)
print('新的一维数组为：n',arr.reshape(3,4))
print('新的一维数组为：',arr.reshape(3,4).ndim)
 
创建的一维数组为：
 [ 0  1  2  3  4  5  6  7  8  9 10 11]
新的一维数组为：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
新的一维数组为： 2
 
展平数组实例
 
# 使用ravel函数展平数组
arr=np.arange(12).reshape(3,4)
print('创建的二维数组为：n',arr)
print('ravel函数数组展平后：',arr.ravel())
 
创建的二维数组为：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
ravel函数数组展平后： [ 0  1  2  3  4  5  6  7  8  9 10 11]
 
# 使用flatten函数展平数组
print('flatten函数数组横向展平为：',arr.flatten())
print('flatten函数数组纵向展平为：',arr.flatten('F'))
 
flatten函数数组横向展平为： [ 0  1  2  3  4  5  6  7  8  9 10 11]
flatten函数数组纵向展平为： [ 0  4  8  1  5  9  2  6 10  3  7 11]
 
组合数组实例
 
# 使用hstack函数数组横向组合
arr1 = np.arange(12).reshape(3,4)
print('创建的数组1为：n',arr1)
arr2=arr1*3
print('创建的数组2为：n',arr2)
print('hstack函数横向组合数组：n',np.hstack((arr1,arr2)))
 
创建的数组1为：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
创建的数组2为：
 [[ 0  3  6  9]
 [12 15 18 21]
 [24 27 30 33]]
横向组合：
 [[ 0  1  2  3  0  3  6  9]
 [ 4  5  6  7 12 15 18 21]
 [ 8  9 10 11 24 27 30 33]]
 
# 使用vstack函数数组纵向组合
print('vstack函数纵向组合数组：n',np.vstack((arr1,arr2)))
 
vstack纵向组合：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [ 0  3  6  9]
 [12 15 18 21]
 [24 27 30 33]]
 
print('concatenate函数横向组合数组：n',np.concatenate((arr1,arr2),axis=1))
print('concatenate函数纵向组合数组：n',np.concatenate((arr1,arr2),axis=0))
 
concatenate函数横向组合数组：
 [[ 0  1  2  3  0  3  6  9]
 [ 4  5  6  7 12 15 18 21]
 [ 8  9 10 11 24 27 30 33]]
concatenate函数纵向组合数组：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [ 0  3  6  9]
 [12 15 18 21]
 [24 27 30 33]]
 
分割数组实例
 
arr=np.arange(16).reshape(4,4)
print('创建的二维数组为：',arr)
print('hsplit函数横向分割数组：n',np.hsplit(arr,2))
print('vsplit函数纵向分割数组：n',np.vsplit(arr,2))
 
创建的二维数组为： [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
hsplit函数横向分割数组：
 [array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
vsplit函数纵向分割数组：
 [array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
 
print('split函数横向分割数组：n',np.split(arr,2,axis=1))
print('split函数纵向分割数组：n',np.split(arr,2,axis=0))
 
split函数横向分割数组：
 [array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
split函数纵向分割数组：
 [array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
 
numpy矩阵与通用函数 
创建numpy矩阵 
矩阵特有属性及说明
 
属性
说明
T
返回自身的转置
H
返回自身的共轭转置
I
返回自身的逆矩阵
A
返回自身数据的二维数组的一个视图
创建矩阵实例
 
# 使用mat函数与matrix函数创建矩阵
import numpy as pd
matr1=np.mat("1 2 3;4 5 6;7 8 9")
print('mat创建的矩阵为：n',matr1)
matr2=np.mat([[1,2,3],[4,5,6],[7,8,9]])
print('matrix创建的矩阵为：n',matr2)
 
mat创建的矩阵为：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
matrix创建的矩阵为：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
 
arr1=np.eye(3)
print('创建的数组1为：n',arr1)
arr2=3*arr1
print('创建的数组2为：n',arr2)
print('bmat创建的矩阵为：n',np.bmat("arr1 arr2;arr1 arr2"))
 
创建的数组1为：
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
创建的数组2为：
 [[3. 0. 0.]
 [0. 3. 0.]
 [0. 0. 3.]]
bmat创建的矩阵为：
 [[1. 0. 0. 3. 0. 0.]
 [0. 1. 0. 0. 3. 0.]
 [0. 0. 1. 0. 0. 3.]
 [1. 0. 0. 3. 0. 0.]
 [0. 1. 0. 0. 3. 0.]
 [0. 0. 1. 0. 0. 3.]]
 
矩阵运算实例
 
# 矩阵运算
matr1=np.mat("1 2 3;4 5 6;7 8 9")
print('创建的矩阵为：n',matr1)
matr2=matr1*3
print('创建的矩阵为：n',matr2)
print('矩阵相加的结果为：n',matr1+matr2)
print('矩阵相减的结果为：n',matr1-matr2)
print('矩阵相乘的结果为：n',matr1*matr2)
print('矩阵对应元素相乘的结果为：n',np.multiply(matr1,matr2))
 
创建的矩阵为：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
创建的矩阵为：
 [[ 3  6  9]
 [12 15 18]
 [21 24 27]]
矩阵相加的结果为：
 [[ 4  8 12]
 [16 20 24]
 [28 32 36]]
矩阵相减的结果为：
 [[ -2  -4  -6]
 [ -8 -10 -12]
 [-14 -16 -18]]
矩阵相乘的结果为：
 [[ 90 108 126]
 [198 243 288]
 [306 378 450]]
矩阵对应元素相乘的结果为：
 [[  3  12  27]
 [ 48  75 108]
 [147 192 243]]
 
# 查看矩阵属性
print('矩阵转置结果为：n',matr1.T)
print('矩阵共轭转置结果为：n',matr1.H)
try:
    print(matr1.I)
except:
    print("奇异矩阵，逆矩阵不存在！")
print('矩阵的二维数组结果为（返回矩阵视图）：n',matr1.A)
 
矩阵转置结果为：
 [[1 4 7]
 [2 5 8]
 [3 6 9]]
矩阵共轭转置结果为：
 [[1 4 7]
 [2 5 8]
 [3 6 9]]
奇异矩阵，逆矩阵不存在！
矩阵的二维数组结果为（返回矩阵视图）：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
 
ufunc函数 
ufunc函数：通用函数，能够对数组中的所有元素进行操作的函数，针对数组进行操作；当对一个数组进行重复运算时，使用ufunc函数比使用math库中的函数效率要高得多。
 
常用ufunc函数：四则运算、比较运算和逻辑运算。
ufunc函数的广播机制
 
# 一维数组的广播机制
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：n',arr1)
print('数组1的shape为：n',arr1.shape)
arr2=np.array([1,2,3])
print('创建的数组2为：n',arr2)
print('数组2的shape为：n',arr2.shape)
print('数组相加的结果为：n',arr1+arr2)
 
创建的数组1为：
 [[0 0 0]
 [1 1 1]
 [2 2 2]
 [3 3 3]]
数组1的shape为：
 (4, 3)
创建的数组2为：
 [1 2 3]
数组2的shape为：
 (3,)
数组相加的结果为：
 [[1 2 3]
 [2 3 4]
 [3 4 5]
 [4 5 6]]
 
# 二维数组的广播机制
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：n',arr1)
print('数组1的shape为：n',arr1.shape)
arr2=np.array([1,2,3,4]).reshape((4,1))
print('创建的数组2为：n',arr2)
print('数组2的shape为：n',arr2.shape)
print('数组相加的结果为：n',arr1+arr2)
 
创建的数组1为：
 [[0 0 0]
 [1 1 1]
 [2 2 2]
 [3 3 3]]
数组1的shape为：
 (4, 3)
创建的数组2为：
 [[1]
 [2]
 [3]
 [4]]
数组2的shape为：
 (4, 1)
数组相加的结果为：
 [[1 1 1]
 [3 3 3]
 [5 5 5]
 [7 7 7]]
 
利用numpy进行统计分析 
读/写文件 
save以二进制的格式保存数据，load函数从二进制的文件中读取数据。
 np.save(file,arr,allow_pickle=True,fix_imports=True)
 
实例
 
# 二进制存储
import numpy as np
arr=np.arange(100).reshape(10,10)
np.save("./save_arr",arr)
print('保存的数组为：n',arr)
 
保存的数组为：
 [[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]
 
# 多个数组存储
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.arange(0,1.0,0.1)
np.savez('./savez_arr',arr1,arr2)
print('保存的数组1为：n',arr1)
print('保存的数组2为：',arr2)
 
保存的数组1为：
 [[1 2 3]
 [4 5 6]]
保存的数组2为： [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
 
# 二进制文件读取
loaded_data = np.load("./save_arr.npy")
print('读取的数组为：n',loaded_data)
 
读取的数组为：
 [[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]
 
# 读取含有多个数组的文件
loaded_data1=np.load('./savez_arr.npz')
print('读取的数组1为：n',loaded_data1['arr_0'])
print('读取的数组2为：n',loaded_data1['arr_1'])
 
savetxt函数将数组写道以某种分隔符隔开的文本文件中。
 np.savetxt(fname,X,fmt='%.18e',delimiter=' ',newline='n',header='',footer='',comments='# '
 第一个参数时文件名fname，第二个参数X为数组数据，第四个参数为数据分隔符felimiter。
 loadtxt函数执行的数相反的操作，即把文件加载到一个二维数组中。
 
读取的数组1为：
 [[1 2 3]
 [4 5 6]]
读取的数组2为：
 [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
 
arr=np.arange(0,12,0.5).reshape(4,-1)
print('创建的数组为：',arr)
 
创建的数组为： [[ 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]]
 
# fmt ="%d"表示保存为整数
np.savetxt("./arr.txt",arr,fmt="%d",delimiter=",")
# 读入的时候也需要指定逗号分割
loaded_data=np.loadtxt("./arr.txt",delimiter=",")
print("读取的数组为：",loaded_data)
 
读取的数组为： [[ 0.  0.  1.  1.  2.  2.]
 [ 3.  3.  4.  4.  5.  5.]
 [ 6.  6.  7.  7.  8.  8.]
 [ 9.  9. 10. 10. 11. 11.]]
 
# 使用genfromtxt函数读取数组
loaded_data=np.genfromtxt("./arr.txt",delimiter=",")
print('读取的数组为：',loaded_data)
 
读取的数组为： [[ 0.  0.  1.  1.  2.  2.]
 [ 3.  3.  4.  4.  5.  5.]
 [ 6.  6.  7.  7.  8.  8.]
 [ 9.  9. 10. 10. 11. 11.]]
 
使用函数进行简单的统计分析 
排序–sort、argsort、lexsort
 
sort实例
 
np.random.seed(42)
arr=np.random.randint(1,10,size=10)
print('创建的数组为：',arr)
# 直接排序
arr.sort()
print('排序后数组为：',arr)
arr=np.random.randint(1,10,size=(3,3))
print('创建的数组为：n',arr)
arr.sort(axis=1)
print('沿着横轴排序后数组为：n',arr)
arr.sort(axis=0)
print('沿着纵轴排序后数组为：n',arr)
 
创建的数组为： [7 4 8 5 7 3 7 8 5 4]
排序后数组为： [3 4 4 5 5 7 7 7 8 8]
创建的数组为：
 [[8 8 3]
 [6 5 2]
 [8 6 2]]
沿着横轴排序后数组为：
 [[3 8 8]
 [2 5 6]
 [2 6 8]]
沿着纵轴排序后数组为：
 [[2 5 6]
 [2 6 8]
 [3 8 8]]
 
argsort实例
 
arr=np.array([2,3,6,8,0,7])
print('创建的数组为：',arr)
print('排序后数组为：',arr.argsort())
# 返回值为重新排序值的下标
 
创建的数组为： [2 3 6 8 0 7]
排序后数组为： [4 0 1 2 5 3]
 
lexsort实例
 
a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])
# lexsort只接收一个参数，即abc
# 多个键值排序时是按照最后一个传入数据计算的
d=np.lexsort((a,b,c))
print('排序后的数组为：',list(zip(a[d],b[d],c[d])))
 
排序后的数组为： [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
 
去重与重复数据
 
unique去重实例
 
names=np.array(['小明','小花','小黄','小明','小花','小兰','小白'])
print('创建的数组names为：',names)
print('去重后数组names为：',np.unique(names))
# 跟unique等价的python代码实现过程
print('python代码去重后的数组为：',sorted(set(names)))
ints=np.array([1,2,3,4,4,5,6,6,7,7,7,8,9,10])
print('创建的数组ints为：',ints)
print('去重后数组ints为：',np.unique(ints))
 
创建的数组names为： ['小明' '小花' '小黄' '小明' '小花' '小兰' '小白']
去重后数组names为： ['小兰' '小明' '小白' '小花' '小黄']
python代码去重后的数组为： ['小兰', '小明', '小白', '小花', '小黄']
创建的数组ints为： [ 1  2  3  4  4  5  6  6  7  7  7  8  9 10]
去重后数组ints为： [ 1  2  3  4  5  6  7  8  9 10]
 
tile函数实现数据重复
 
arr=np.arange(5)
print('创建的数组为：',arr)
print('重复后数组为：',np.tile(arr,3))
 
创建的数组为： [0 1 2 3 4]
重复后数组为： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
 
repeat函数实现数据重复
 
np.random.seed(42)
arr=np.random.randint(0,10,size=(3,3))
print('创建的数组为：',arr)
print('按行进行元素重复，重复后数组为：n',arr.repeat(2,axis=0))
print('按列进行元素重复，重复后数组为：n',arr.repeat(2,axis=1))
 
创建的数组为： [[6 3 7]
 [4 6 9]
 [2 6 7]]
按行进行元素重复，重复后数组为：
 [[6 3 7]
 [6 3 7]
 [4 6 9]
 [4 6 9]
 [2 6 7]
 [2 6 7]]
按列进行元素重复，重复后数组为：
 [[6 6 3 3 7 7]
 [4 4 6 6 9 9]
 [2 2 6 6 7 7]]
 
常用的统计函数 
arr=np.arange(20).reshape(4,5)
print('创建的数组为：n',arr)
print('数组的和为：',np.sum(arr))
print('纵轴数组的和为：',arr.sum(axis=0))
print('横轴数组的和为：',arr.sum(axis=1))
print('数组的均值为：',np.mean(arr))
print('纵轴数组的均值为：',arr.mean(axis=0))
print('横轴数组的均值为：',arr.mean(axis=1))
print('数组的标准差为：',np.std(arr))
print('数组的方差为：',np.var(arr))
print('数组的最小值为：',np.min(arr))
print('数组的最大值为：',np.max(arr))
print('数组的最小元素索引为：',np.argmin(arr))
print('数组的最大元素索引为：',np.argmax(arr))
 
创建的数组为：
 [[ 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
纵轴数组的均值为： [ 7.5  8.5  9.5 10.5 11.5]
横轴数组的均值为： [ 2.  7. 12. 17.]
数组的标准差为： 5.766281297335398
数组的方差为： 33.25
数组的最小值为： 0
数组的最大值为： 19
数组的最小元素索引为： 0
数组的最大元素索引为： 19
 
# cumsum和cumprod函数的使用
arr=np.arange(2,10)
print('创建的数组为：',arr)
print('数组元素的累计和为：',np.cumsum(arr))
print('数组元素的累计积为：',np.cumprod(arr))
 
创建的数组为： [2 3 4 5 6 7 8 9]
数组元素的累计和为： [ 2  5  9 14 20 27 35 44]
数组元素的累计积为： [     2      6     24    120    720   5040  40320 362880]
 
鸢尾花长度数据统计分析 
# 鸢尾花统计分析
iris_sepal_length=np.loadtxt('E:/anaconda/data/iris_sepal_length.csv',delimiter=',')
print('花萼长度表为：',iris_sepal_length)
iris_sepal_length.sort()
print('排序后的花萼长度表为：',iris_sepal_length)
 
花萼长度表为： [5.1 4.9 4.7 4.6 5.  5.4 4.6 5.  4.4 4.9 5.4 4.8 4.8 4.3 5.8 5.7 5.4 5.1
 5.7 5.1 5.4 5.1 4.6 5.1 4.8 5.  5.  5.2 5.2 4.7 4.8 5.4 5.2 5.5 4.9 5.
 5.5 4.9 4.4 5.1 5.  4.5 4.4 5.  5.1 4.8 5.1 4.6 5.3 5.  7.  6.4 6.9 5.5
 6.5 5.7 6.3 4.9 6.6 5.2 5.  5.9 6.  6.1 5.6 6.7 5.6 5.8 6.2 5.6 5.9 6.1
 6.3 6.1 6.4 6.6 6.8 6.7 6.  5.7 5.5 5.5 5.8 6.  5.4 6.  6.7 6.3 5.6 5.5
 5.5 6.1 5.8 5.  5.6 5.7 5.7 6.2 5.1 5.7 6.3 5.8 7.1 6.3 6.5 7.6 4.9 7.3
 6.7 7.2 6.5 6.4 6.8 5.7 5.8 6.4 6.5 7.7 7.7 6.  6.9 5.6 7.7 6.3 6.7 7.2
 6.2 6.1 6.4 7.2 7.4 7.9 6.4 6.3 6.1 7.7 6.3 6.4 6.  6.9 6.7 6.9 5.8 6.8
 6.7 6.7 6.3 6.5 6.2 5.9]
排序后的花萼长度表为： [4.3 4.4 4.4 4.4 4.5 4.6 4.6 4.6 4.6 4.7 4.7 4.8 4.8 4.8 4.8 4.8 4.9 4.9
 4.9 4.9 4.9 4.9 5.  5.  5.  5.  5.  5.  5.  5.  5.  5.  5.1 5.1 5.1 5.1
 5.1 5.1 5.1 5.1 5.1 5.2 5.2 5.2 5.2 5.3 5.4 5.4 5.4 5.4 5.4 5.4 5.5 5.5
 5.5 5.5 5.5 5.5 5.5 5.6 5.6 5.6 5.6 5.6 5.6 5.7 5.7 5.7 5.7 5.7 5.7 5.7
 5.7 5.8 5.8 5.8 5.8 5.8 5.8 5.8 5.9 5.9 5.9 6.  6.  6.  6.  6.  6.  6.1
 6.1 6.1 6.1 6.1 6.1 6.2 6.2 6.2 6.2 6.3 6.3 6.3 6.3 6.3 6.3 6.3 6.3 6.3
 6.4 6.4 6.4 6.4 6.4 6.4 6.4 6.5 6.5 6.5 6.5 6.5 6.6 6.6 6.7 6.7 6.7 6.7
 6.7 6.7 6.7 6.7 6.8 6.8 6.8 6.9 6.9 6.9 6.9 7.  7.1 7.2 7.2 7.2 7.3 7.4
 7.6 7.7 7.7 7.7 7.7 7.9]
 
print('去重后的花萼长度表为：',np.unique(iris_sepal_length))
print('花萼长度表总和为：',np.sum(iris_sepal_length))
print('花萼长度表的累计和为：',np.cumsum(iris_sepal_length))
print('花萼长度表的均值为：',np.mean(iris_sepal_length))
print('花萼长度表的标准差为：',np.std(iris_sepal_length))
print('花萼长度表的方差为：',np.var(iris_sepal_length))
print('花萼长度表的最小值为：',np.min(iris_sepal_length))
print('花萼长度表的最大值为：',np.max(iris_sepal_length))
 
去重后的花萼长度表为： [4.3 4.4 4.5 4.6 4.7 4.8 4.9 5.  5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 6.
 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7.  7.1 7.2 7.3 7.4 7.6 7.7 7.9]
花萼长度表总和为： 876.5
花萼长度表的累计和为： [  4.3   8.7  13.1  17.5  22.   26.6  31.2  35.8  40.4  45.1  49.8  54.6
  59.4  64.2  69.   73.8  78.7  83.6  88.5  93.4  98.3 103.2 108.2 113.2
 118.2 123.2 128.2 133.2 138.2 143.2 148.2 153.2 158.3 163.4 168.5 173.6
 178.7 183.8 188.9 194.  199.1 204.3 209.5 214.7 219.9 225.2 230.6 236.
 241.4 246.8 252.2 257.6 263.1 268.6 274.1 279.6 285.1 290.6 296.1 301.7
 307.3 312.9 318.5 324.1 329.7 335.4 341.1 346.8 352.5 358.2 363.9 369.6
 375.3 381.1 386.9 392.7 398.5 404.3 410.1 415.9 421.8 427.7 433.6 439.6
 445.6 451.6 457.6 463.6 469.6 475.7 481.8 487.9 494.  500.1 506.2 512.4
 518.6 524.8 531.  537.3 543.6 549.9 556.2 562.5 568.8 575.1 581.4 587.7
 594.1 600.5 606.9 613.3 619.7 626.1 632.5 639.  645.5 652.  658.5 665.
 671.6 678.2 684.9 691.6 698.3 705.  711.7 718.4 725.1 731.8 738.6 745.4
 752.2 759.1 766.  772.9 779.8 786.8 793.9 801.1 808.3 815.5 822.8 830.2
 837.8 845.5 853.2 860.9 868.6 876.5]
花萼长度表的均值为： 5.843333333333334
花萼长度表的标准差为： 0.8253012917851409
花萼长度表的方差为： 0.6811222222222223
花萼长度表的最小值为： 4.3
花萼长度表的最大值为： 7.9