(python)Numpy

掌握数组对象ndarray

创建数组对象

• 数组属性：ndarray（数组）储存单一数据的多维数组

属性	说明
ndim	返回 int。表示数组的维数
shape	返回 tuple。表示数组的尺寸，对于 n 行 m 列的矩阵，形状为(n,m)
size	返回 int。表示数组的元素总数，等于数组形状的乘积
dtype	返回 data-type。描述数组中元素的类型
itemsize	返回 int。表示数组的每个元素的大小（以字节为单位）

import numpy as np

arr1 = np.array([[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9]])
print("数组：", arr1)
print("ndim:", arr1.ndim)
print("shape：", arr1.shape)
print("size:", arr1.size)
print("dtype:", arr1.dtype)
print("itemsize:", arr1.itemsize)

arr1.shape = 3, 4
print("数组：", arr1)

数组

创建数组

1. 使用array创建数组：
	numpy.array(object, dtype = None, copy = Ture, order = "K", subok = False, ndmin = 0)

参数名称	说明
object	接收array。表示想要创建的数组。无默认。
dtype	接收data-type。表示数组所需的数据类型。如果未给定，则选择保存对象所需的最小类型。默认为None。
ndmin	接收int。指定生成数组应该具有的最小维数。默认为None。

2.  使用 arange 函数创建数组
np.aarange( 头(含)，尾(不含)，步长)
头默认0
步长默认1

print('使用 arange 函数创建的数组为：\n',np.arange(0,1,0.1))
Out:使用arange函数创建的数组为： 
[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]

3. 使用 linspace 函数创建数组
np.lispace(头(含), 尾(含),个数)
**向量长度：数组的列数。。**

arr1 = np.linspace(0,10,5)
print(arr1)
>>> [ 0.   2.5  5.   7.5 10. ]

4. 使用 logspace 函数创建等比数列
np.logspace(头幂(含)，尾幂(含),  长度，base = 10 )
**base:底数 。默认为10**

arr1 = np.logspace(1, 5, 5, base=2)
print(arr1)

>>> [ 2.  4.  8. 16. 32.]

开始为 2^1
结束为 2^5
数组长度为5
底数base设置为2.

5. 使用zeros函数创建数组
np.zeros((行数, 列数))

arr1 = np.zeros((2, 5))
print(arr1)
>>> [[0. 0. 0. 0. 0.]
>>> [0. 0. 0. 0. 0.]]

6. 使用eye函数创建数组
np.eye(行数)

arr1 = np.eye(5)
print(arr1)

>>>[[1. 0. 0. 0. 0.]
>>> [0. 1. 0. 0. 0.]
>>> [0. 0. 1. 0. 0.]
>>> [0. 0. 0. 1. 0.]
>>> [0. 0. 0. 0. 1.]]

7. 使用diag函数创建数组
np.diag([数组])

arr1 = np.diag([1,2,2,3,8,9])
print(arr1)
>>>[[1 0 0 0 0 0]
>>> [0 2 0 0 0 0]
>>>[0 0 2 0 0 0]
>>>[0 0 0 3 0 0]
>>>[0 0 0 0 8 0]
>>>[0 0 0 0 0 9]]

8. 使用ones函数创建数组
np.ones((行数， 列数))

arr1 = np.ones((5,3))
print(arr1)
>>>[[1. 1. 1.]
>>> [1. 1. 1.]
>>> [1. 1. 1.]
>>> [1. 1. 1.]
>>> [1. 1. 1.]]


 

9. 使用full创建自定义元素函数
np.full(shape,fill_value) 

img1 = np.full(shape=(300,400,3),fill_value=123，dtype=int)
print(img1)
>>>
>[[[123 123 123]
  [123 123 123]
  [123 123 123]
  ...
  [123 123 123]
  [123 123 123]
  [123 123 123]]

 [[123 123 123]
  [123 123 123]
  [123 123 123]
  ...
  [123 123 123]
  [123 123 123]
  [123 123 123]]

fill_value=想要填充的值

数组数据类型

类型	描述
bool	用一位存储的布尔类型（值为TRUE或FALSE）
inti	由所在平台决定其精度的整数（一般为int32或int64）
int8	整数，范围为−128至127
int16	整数，范围为−32768至32767
int32
…………

1. 数组数据类型转换
   格式： np.数据类型(数组)
   In[15]:print(‘转换结果为：’,np.float64(42)) #整型转换为
   浮点型
   Out[15]:转换结果为： 42.0

2. 创建数据类型

   • 语法：
     df = np.dtype([(“名称1”, 数据类型1),(“名称2”, 数据类型2),……,(“名称n”, 数据类型n)])
   • 例：
     创建一个存储餐饮企业库存信息的数据类型。其中，用一个长度为40个字符的字符串来记录商品的
     名称，用一个64位的整数来记录商品的库存数量，最后用一个64位的单精度浮点数来记录商品的价
     格，具体步骤如下。

df = np.dtype([("name", np.str_, 40), ("min", np.int64), ("pri", np.float64)])
print(df)
>>>[('name', '<U40'), ('min', '<i8'), ('pri', '<f8')]

3. 查看数据类型
   np.dtype()

df = np.dtype([("name", np.str_, 40), ("min", np.int64), ("pri", np.float64)])
print(df)

print(df["min"])
print(np.dtype(df["pri"]))


>>>[('name', '<U40'), ('min', '<i8'), ('pri', '<f8')]
>>>int64
>>>float64

生成随机数据

1. 无约束生成随机数
   np.random.random(个数)
   个数可替换为维度如np.random.random((2, 3))生成2行三列矩阵
   默认从0~1中随机

arr1 = np.random.random(10)
print(arr1)

>>>[0.83990735 0.95481672 0.00702237 0.58501854 0.02289544 0.25005868 0.88082806 0.27365091 0.53659921 0.33075266]

2. 生成服从均匀分布的随机数

   np.random.rand(行数， 列数)

arr1 = np.random.rand(2, 5)
print(arr1)

>>>[[0.80889454 0.22729104 0.47939081 0.45343364 0.35907224]
>>> [0.42704999 0.22108906 0.60836079 0.57490138 0.87255894]]

3. 生成服从正态分布的随机数
   np.random.randn(行数， 列数)

arr1 = np.random.randn(2, 5)
print(arr1)
>>>[[-0.07669569  1.94912026 -0.31178538 -0.20962431 -1.31098436]
>>> [-0.25470858  0.80907602 -0.22767302  0.62875092 -0.48969277]]

4. 生成给定上下范围的随机数
   np.random.randint(头, 尾，size=[行数，列数])
   · 如创建一个最小值不低于 2、最大值不高于 10 的 2 行 5 列数组

arr1 = np.random.randint(2, 10, size=[2, 5])
print(arr1)
>>>[[7 3 8 7 9]
>>> [6 7 4 4 7]]

5. random常用随机数生成函数

函数	说明
seed	确定随机数生成器的种子。
permutation	返回一个序列的随机排列或返回一个随机排列的范围。
shuffle	对一个序列进行随机排序。
binomial	产生二项分布的随机数。
normal	产生正态（高斯）分布的随机数。
beta	产生beta分布的随机数。
chisquare	产生卡方分布的随机数。
gamma	产生gamma分布的随机数。
uniform	产生在[0,1)中均匀分布的随机数。

通过索引访问数组

1. 一维数组索引

// arr2 = np.arange(10)
// >>>[1 2 3 4 5 6 7 8 9]
arr1 = np.arange(1,20,2)
print(arr1)
print(arr1[5])
>>>[ 1  3  5  7  9 11 13 15 17 19]
>>>11

索引与list索引相同，索引切片。。倒序
还可以根据索引修改元素值

2. 多维数组的索引
   数组名[第几行， 第几个]
   第几个可以索引，可以切片，可以倒序

arr1 = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print(arr1)
print(arr1[1,4:1:-1])
>>>[[ 1  2  3  4  5]
>>> [ 4  5  6  7  8]
>>> [ 7  8  9 10 11]]

>>>[8 7 6]

• 例：索引第2和3行中第3～5列的元素

arr1 = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print(arr1[1:3,2:])
>>>[[ 6  7  8]
>>> [ 9 10 11]]

• 索引第三列

print(arr1[,2:])
>>>[3 6 9]

改变数组形状

1. arr.reshape(行，列)

arr1 = np.arange(12)
print(arr1)
print(arr1.reshape(3,4))

>>>[ 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函数展平数组（不会产生新数组，只得到一个视图）

print(arr1.reshape(3,4).ravel())
>>>[ 0  1  2  3  4  5  6  7  8  9 10 11]

3. 使用flatten平展数组（会新建一个数组）

print(arr2)
# 横向平展
print(arr2.flatten())
# 纵向平展
print(arr2.flatten('F'))
>>>
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
[ 1  2  3  4  4  5  6  7  7  8  9 10]
[ 1  4  6  8  2  4  7  9  3  5  7 10]

4. transpose转置函数
   参考

组合数组

1. 使用hstach函数数组横向组合
   np.hstach((arr1,arr2))

print(np.hstack((arr2,arr2)))

>>>
>[[ 1  2  3  1  2  3]
 [ 4  4  5  4  4  5]
 [ 6  7  7  6  7  7]
 [ 8  9 10  8  9 10]]

2. vstack 纵向组合数组

print(np.vstack((arr2,arr2)))

>>>
>[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]
 [ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]

3. concatenate组合数组
   np.concatenate((arr1,arr2), axis=0/1)
   axis=1:横向组合
   axis=0:纵向组合（默认为0）

切割数组

1. hsplit横向切割:将数组横着平分切割
   np.hsplit(arr1,x)
   x:切割份数

print(arr3)
print(np.hsplit(arr3, 4))

>>>
>[ 1  4  6  8  2  4  7  9  3  5  7 10]
[array([1, 4, 6]), array([8, 2, 4]), array([7, 9, 3]), array([ 5,  7, 10])]

arr3 = np.arange(0,9).reshape((3,3))
print(arr3)
print(np.hsplit(arr3,3))
>>>
>[[0 1 2]
 [3 4 5]
 [6 7 8]]
[array([[0],
       [3],
       [6]]), array([[1],
       [4],
       [7]]), array([[2],
       [5],
       [8]])]

2. vsplit纵向切割：将数组纵向，分为三块

print(arr2)
print(np.vsplit(arr2,4))

>>>
>[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
[array([[1, 2, 3]]), array([[4, 4, 5]]), array([[6, 7, 7]]), array([[ 8,  9, 10]])]

3. split分割
   np.split(arr,x,axis=1/0)
   x:切割份数，
   axis：1横向、0纵向

arr = np.arange(1,10)
print(arr)
print(np.split(arr,[3,5]))
>>>
>[1 2 3 4 5 6 7 8 9]
[array([1, 2, 3]), array([4, 5]), array([6, 7, 8, 9])]

当x为数组时，按照位置切，在索引为3的前面，索引为5的前面切割。

y = x.reshape((3,3))
print(y)

x1, x2 = np.split(y,(1,))
print(x1)
print(x2)
>>>
>[[1 2 3]
 [4 5 6]
 [7 8 9]]
 
x1:[[1 2 3]]

x2:[[4 5 6]
 [7 8 9]]

当x为元祖时…

numpy矩阵与通用函数

创建numpy矩阵

1. mat函数
   matrl = np.mat(“1 2 3;4 5 6;7 8 9”)

matrl = np.mat("1 2 3; 4 5 6; 7 8 9")
print(matrl)
>>>
>[[1 2 3]
 [4 5 6]
 [7 8 9]]

2. matrix函数

   matrl1 = np.matrix([[123],[456],[789]])

matrl1 = np.matrix([[123],[456],[789]])
print(matrl1)
>>>
>[[123]
 [456]
 [789]]

3. bmat合成矩阵
   np.bmat(“arr1 arr2;arr2 arr1”)

print(matr1)
print(matr2)
>>>
>[[2 3]
 [4 5]]
[[5 6]
 [7 8]]
print(np.bmat("matr1 matr2;matr2 matr1"))
>>>
>[[2 3 5 6]
 [4 5 7 8]
 [5 6 2 3]
 [7 8 4 5]]

矩阵的运算

和正常加减乘除差不多。将矩阵中的每一个元素都相互运算

ufunc函数

• 简介：通用函数，对数组中所有元素进行操做

1.
2.
3.

ufunc函数的广播机制

广播指不同形状的数组之间执行算数运算的方式。遵循以下四个原则：
1. 让所有输入数组看齐其中最长shape 的数组，shape中不足在前加1补足
2. 输出数组的shape是输入数组shape的各个轴上的最大值
3. 输入数组的某个轴与输出数组对应轴长度相同 或为1，可以计算，否则报错
4. 输入数组的某轴长度为1，沿次轴运算都用此轴的第一组数值

一维数组广播机制

二维数组广播机制

numpy进行数据统计分析

读写文件

主要有二进制文件读写和文件列表形式的数据读写两种形式

读写二进制文件

存储型可以不写扩展名，读取时必须要写

1. save
   以二进制的格式保存数据
   np.save(“路径/文件名(可以不写扩展名.npy)”,arr)
2. load
   从二进制的格式中读取数据
   arr = np.(“路径/文件名.npy”)
3. savez
   将多个数组保存到一个文件
   np.savez(“路径/文件名(可以不写扩展名.npy)”,arr1,arr2,arr3)

读写文本文件

1. savetext
   将数组写到某种分隔符隔开的文件本文件中
   np.savetxt(“保存路径/文件名.txt”,arr数据,fmt="%d",delimiter=“以什么符号分开”)

np.savetxt("./aaaa.txt",arr2,fmt="%d",delimiter=",")

2. looadtxt
   读取文件加载到二维数组
   arr = np.loadtxt(“路径/文件名.txt”,delimiter=“分隔符”)

np.savetxt("./aaaa.txt",arr2,fmt="%d",delimiter=",")
arr = np.loadtxt("./aaaa.txt",delimiter=",")
print(arr)
>>>
>[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]

3. genfromtxt
   面向结构化数据和缺失数据
   np.genfromtxt(“路径/文件名.txt”,delimiter=“分隔符”)
   效果和loadtxt差不多
   

使用数组进行简单数据分析

排序

1. 直接排序sort
   arr.sort(axis=1)
   改变arr数组不返回值,axis默认为1，横排，0位纵排，可省略

arr2 = np.array([[2,3,1],[4,1,22],[44,55,6]])
print(arr2)
print("----------------")
arr2.sort()
print(arr2)
print("----------------")
arr2 = np.array([[2,3,1],[4,1,22],[44,55,6]])
print(arr2)
print("----------------")
arr2.sort(0)
print(arr2)
>>>
>[[ 2  3  1]
 [ 4  1 22]
 [44 55  6]]
----------------
[[ 1  2  3]
 [ 1  4 22]
 [ 6 44 55]]
----------------
[[ 2  3  1]
 [ 4  1 22]
 [44 55  6]]
----------------
[[ 2  1  1]
 [ 4  3  6]
 [44 55 22]]

2. 间接排序
   • argsort 返回重新排序值得下标arr.argsort()

去重与数据重复

1. np.unique(arr)
   返回唯一值并返回已排序结果

arr = np.loadtxt("./iris_sepal_length.csv",delimiter=" ")
print(arr)
print("去重：\n",np.unique(arr))

>>>
>[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.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]

2. np.tile(A,reps)
   A:指定重复数组，reps指定重复次数
3. np.repeat(a, repeats,asix=None)
   A:指定重复数组，repeats指定重复次数,asix表示按照哪个轴重复

常用统计函数

默认都有axis属性 为1，沿横计算。0位沿纵计算

函数	说明
sum	数组的和
mean	数组的均值
std	标准差
var	方差
min	最小值
max	最大值
argmin	最小值索引
argmax	最大值索引
cumsum	所有元素累计和
cumprod	所有元素累计积