python学习之numpy

1、ndarray

Numpy 的数组类称做 ndarry，别名是 array。注意 numpy.array 和 Python 标准库的类 array.array 不同，标准库的类只处理一维数组（one-dimensional arrays）。

1.1入门例子

使用numpy对列表中每个元素进行开平方运算

import numpy as np
import math

a = [3,4,9,15]
result = []
for i in a:
    print(math.sqrt(i))
    result.append(math.sqrt(i))

print(result)
print(np.sqrt(a))

1.2使用array函数创建ndarray

import numpy as np

# 使用array函数创建一维数组
a = np.array([1,2,3,4])
print(a)
print(type(a))

# 使用array函数创建二维数组
b = np.array([[11,12,13],[21,22,23],[31,32,33]])
print(b)
print(type(b))

# 使用array函数创建三维数组
c = np.array([[[11,12,13],[21,22,23],[31,32,33]],[[211,212,213],[221,222,223],[231,232,233]]])
print(c)
print(type(c))

# 使用dtype设置ndarray中的元素类型
d = np.array([1,2,3,4], dtype=float)
print(d)
print(type(d))

# array函数中ndmin设置ndarray的维度
e = np.array([1,2,3], dtype=float, ndmin=4)
print(e)
print(type(e))

注意，使用array函数创建多维数组时，每个维度下元素内部必须一致，否则会报错

VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify ‘dtype=object’ when creating the ndarray.

2、numpy基础数据结构

2.1练习

import numpy as np

arr = np.array([[1,2,3,4],[1,2,3,4]])
print(arr, type(arr))
print(arr.ndim) # ndim数组维度的个数(轴数)
print(arr.shape) # 数组的维度，对于n行m列的数组，shape为(n, m)
print(arr.size) # 数组中元素的个数
print(type(arr), arr.dtype) # dtype数组中元素的类型
print(arr.itemsize) # 每个元素的字节数
print(arr.data) # 数组数据对象在内存中的起始地址

ar1 = np.array(range(10))
ar2 = np.arange(10)
ar3 = np.array([1,2,3])
ar4 = np.array([[1,2,3], [1,2,3]])
# 如果多维数组类型不一致，所有元素都会转成字符串，如果多维数组元素个数不一致，则会转成一维数组
ar5 = np.array([[1,2,3], ['a','b','c']])
ar6 = np.random.rand(10).reshape(2, 5)
print(ar1)
print(ar2)
print(ar3)
print(ar4)
print(ar5)
print(ar6)


# 创建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。

print(np.arange(10))    # 返回0-9，整型
print(np.arange(10.0))  # 返回0.0-9.0，浮点型
print(np.arange(5,12))  # 返回5-11
print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
print(np.arange(10000))  # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角：

# 创建数组：linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。
br1 = np.linspace(10, 20, 20) # 因为前闭后闭，实际包含21个数
br2 = np.linspace(10, 20, 20, endpoint=False) #
print(br1)
print(br2)
br3 = np.linspace(10, 20, 20, retstep=True) #
print(br3, type(br3))

# zeros创建一个所有元素都是0的元组，第一个参数是维度，第二个参数是元素类型
print(np.zeros(10))
print(np.zeros((3,5), dtype=np.int64))
# zeros_like创建一个和源数组相同但元素都是0的数组
arr1 = np.array([list(range(10)), list(range(10, 20))])
print(arr1)
print(np.zeros_like(arr1))


print(np.ones(10))
print(np.ones((3,5), dtype=np.int64))
# zeros_like创建一个和源数组相同但元素都是0的数组
arr1 = np.array([list(range(10)), list(range(10, 20))])
print(arr1)
print(np.ones_like(arr1))

# 创建数组eye()
print(np.eye(6))
# 创建一个n*n的矩阵，对角线为1，其余元素为0

2.2作业

import numpy as np

# 作业1：分别按照要求，生成一个一维数组、二维数组，并且查看其shape
arr1 = np.array([list(range(10)), list(range(10, 20))])
print(arr1)
print(arr1.shape)

# 作业2：生成一个一维数组，起始值为5，终点值为15，样本数为10个
arr2 = np.linspace(5, 15, 10)
print(arr2)

# 作业3：按照要求创建以下数组
# 3.1 四行四列全部为0
print(np.zeros((4,4), np.int64))
# 3.2 两行三列全部为1
print(np.ones((2,3), np.int64))
# 3.3 三行三列对角线为1，其余元素为0
print(np.eye(3))

3、通用函数

3.1练习

import numpy as np

# 数组形状：.T/.reshape()/.resize()
ar1 = np.arange(10)
ar2 = np.zeros((5,4))
print(ar1)
print(ar2)

print(ar1.T)
print(ar2.T)
print('------')
# .T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变

ar3 = ar1.reshape(2,5)     # 用法1：直接将已有数组改变形状
ar4 = np.zeros((4,6)).reshape(3,8)   # 用法2：生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4))   # 用法3：参数内添加数组，目标形状
print(ar1,'\n',ar3)
print(ar4)
print(ar5)
print('------')
# numpy.reshape(a, newshape, order='C')：为数组提供新形状，而不更改其数据，所以元素数量需要一致！！

ar6 = np.resize(np.arange(5),(3,4))
print(ar6)
# numpy.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！


# 数组的复制

ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
ar1[2] = 9
print(ar1,ar2)
# 回忆python的赋值逻辑：指向内存中生成的一个值 → 这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变

ar3 = ar1.copy()
print(ar3 is ar1)
ar1[0] = 9
print(ar1,ar3)
# copy方法生成数组及其数据的完整拷贝
# 再次提醒：.T/.reshape()/.resize()都是生成新的数组！！！


# 数组类型转换：.astype()

ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype)
print('-----')
# 可以在参数位置设置数组类型

ar2 = ar1.astype(np.int32)
print(ar2,ar2.dtype)
print(ar1,ar1.dtype)
# a.astype()：转换数组类型
# 注意：养成好习惯，数组类型用np.int32，而不是直接int32


# 数组堆叠

a = np.arange(5)    # a为一维数组，5个元素
b = np.arange(5,9) # b为一维数组,4个元素
ar1 = np.hstack((a,b))  # 注意:((a,b))，这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
a = np.array([[1],[2],[3]])   # a为二维数组，3行1列
b = np.array([['a'],['b'],['c']])  # b为二维数组，3行1列
ar2 = np.hstack((a,b))  # 注意:((a,b))，这里形状必须一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
print('-----')
# numpy.hstack(tup)：水平（按列顺序）堆叠数组


a = np.arange(5)
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b))  # 这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
print('-----')
# numpy.vstack(tup)：垂直（按列顺序）堆叠数组

a = np.arange(5)
b = np.arange(5, 10)
print(a)
print(b)
ar1 = np.stack((a, b))
ar2 = np.stack((a,b), axis=1)
print(ar1, ar1.shape)
print(ar2, ar2.shape)
# numpy.stack(arrays, axis=0)：沿着新轴连接数组的序列，形状必须一样！
# 重点解释axis参数的意思，假设两个数组[1 2 3]和[4 5 6]，shape均为(3,0)
# axis=0：[[1 2 3] [4 5 6]]，shape为(2,3)
# axis=1：[[1 4] [2 5] [3 6]]，shape为(3,2)

# 数组拆分

a = np.arange(16).reshape(4,4)
print(a)
print("------------")
ar1 = np.hsplit(a, 2)
ar2 = np.vsplit(a, 2)
print(ar1)
print(ar2)
# numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# numpy.vsplit(ary, indices_or_sections)：:将数组垂直（行方向）拆分为多个子数组 → 按行拆


# 数组简单运算

ar = np.arange(6).reshape(2,3)
print(ar + 10)   # 加法
print(ar * 2)   # 乘法
print(1 / (ar+1))  # 除法
print(ar ** 0.5)  # 幂
# 与标量的运算

print(ar.mean())  # 求平均值
print(ar.max())  # 求最大值
print(ar.min())  # 求最小值
print(ar.std())  # 求标准差
print(ar.var())  # 求方差
print(ar.sum(), np.sum(ar,axis = 0))  # 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(np.sort(np.array([1,4,3,2,5,6])))  # 排序
# 常用函数

3.2作业

import numpy as np

# 作业1：创建一个20个元素的数组，分别改变成两个形状：(4,5),(5,6) （提示：超出范围用resize）

a = np.arange(20)
ar1 = np.reshape(a, (4,5))
print(ar1, ar1.shape)
ar2 = np.resize(a, (5,6))
print(ar2, ar2.shape)

# 作业2：创建一个(4,4)的数组，把其元素类型改为字符型

ar1 = np.reshape(np.arange(16), (4,4))
ar2 = ar1.astype(dtype=str)
print(ar2, ar2.dtype)

# 作业3：根据要求创建数组，运用数组的运算方法得到结果：result = ar * 10 +100，并求出result的均值及求和

ar1 = np.reshape(np.arange(16), (4,4))
print(ar1)
ar2 = (ar1 * 10) + 100
print(ar2)
print(np.average(ar2))
print(np.sum(ar2))

4、Numpy索引及切片

4.1练习

import numpy as np

# 基本索引及切片

ar1 = np.arange(20)
print(ar1)
print(ar1[3])
print(ar1[3:5])
print('-----')
# 一维数组索引及切片

ar1 = np.reshape(np.arange(16), (4,4))
print(ar1, ar1.ndim)
print(ar1[2], ar1[2].ndim)
print(ar1[2][2], ar1[2][2].ndim)
print(ar1[:2], ar1[:2].ndim)
print(ar1[:2, :2])
print('-----')
# 二维数组索引及切片

ar2 = np.reshape(np.arange(27), (3,3,3))
print(ar2, ar2.ndim)
print(ar2[1], ar2[1].ndim)
print(ar2[1][1], ar2[1][1].ndim)
print(ar2[1][1][0], ar2[1][1][0].ndim)
print("-------------------")
# **三维数组索引及切片


# 布尔型索引及切片

ar1 = np.reshape(np.arange(12), (3,4))
print(ar1)
b1 = [True, False, True]
b2 = [False, True, False, True]
print(ar1[b1,:])
print(ar1[:, b2])
# 布尔型索引：以布尔型的矩阵去做筛选

m = ar1>6
print(m) # 这里m是一个判断矩阵
print(ar1[m]) # 用m判断矩阵去筛选ar数组中>5的元素 → 重点！后面的pandas判断方式原理就来自此处


# 数组索引及切片的值更改、复制

ar = np.arange(16)
ar[4] = 100
print(ar)
ar[6:9] = 300
print(ar)
# 一个标量赋值给一个索引/切片时，会自动改变/传播原始数组

arr = ar.copy()
arr[2:6] = 10
print(arr)
print(ar)
# 复制

4.2作业

# 作业1：按照要求创建数组，通过索引，其ar[4]、ar[:2,3:]、ar[3][2]分别是多少
import numpy as np

ar = np.reshape(np.arange(25), (5,5))
print(ar)
print(ar[4])
print(ar[:2, 3:])
print(ar[3][2])

# 作业2：按照要求创建数组，筛选出元素值大于5的值并生成新的数组
ar = np.arange(16)
m = ar > 5
print(ar[m])

5、Numpy随机数

5.1练习

import numpy as np

# numpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一

# 随机数生成

ar = np.random.normal(size=(5,5))
print(ar)
#
# import matplotlib.pyplot as plt  # 导入matplotlib模块，用于图表辅助分析
# # 魔法函数，每次运行自动生成图表 jupyter特有函数
#
# a = np.random.rand()
# print(a,type(a))  # 生成一个随机浮点数
#
# b = np.random.rand(4)
# print(b,type(b))  # 生成形状为4的一维数组
#
# c = np.random.rand(2,3)
# print(c,type(c))  # 生成形状为2*3的二维数组，注意这里不是((2,3))
#
# samples1 = np.random.rand(1000)
# samples2 = np.random.rand(1000)
# plt.scatter(samples1,samples2)
#
#
# #  numpy.random.randn(d0, d1, ..., dn)：生成一个浮点数或N维浮点数组 —— 正态分布
#
# samples1 = np.random.randn(1000)
# samples2 = np.random.randn(1000)
# plt.scatter(samples1,samples2)
# # randn和rand的参数用法一样
# # 生成1000个正太的样本值



# numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组
# 若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low
# dtype参数：只能是int类型

print(np.random.randint(2))
# low=2：生成1个[0,2)之间随机整数

print(np.random.randint(2,size=5))
# low=2,size=5 ：生成5个[0,2)之间随机整数

print(np.random.randint(2,6,size=5))
# low=2,high=6,size=5：生成5个[2,6)之间随机整数

print(np.random.randint(2,size=(2,3)))
# low=2,size=(2,3)：生成一个2x3整数数组,取数范围：[0,2)随机整数

print(np.random.randint(2,6,(2,3)))
# low=2,high=6,size=(2,3)：生成一个2*3整数数组,取值范围：[2,6)随机整数

5.2作业

import numpy as np

# 作业1：请按照要求创建数组ar，再将ar[:2,:2]的值改为[0,1)的随机数
ar = np.reshape(np.arange(25, dtype=float), (5,5))
print(ar)
# 注意，如果创建的ndarray是int类型，这里用浮点型赋值后符合条件的元素都会变成0
ar[:2,:2] = np.random.rand()
print(ar)

# 作业2： 创建2个包含10个元素的正太分布一维数组
ar = np.reshape(np.random.randn(10), (1, 10))
print(ar)
ar2 = np.random.normal(1, size=(1, 10))
print(ar2)

6、Numpy数据的输入输出

6.1练习

import numpy as np
import os
os.chdir("C:/Users/11244/Desktop")

# 存储数组数据 .npy文件

ar = np.random.rand(5, 5)
print(ar)
np.save("test", ar)
# 也可以直接 np.save('C:/Users/11244/Desktop/test', ar)

print(np.load("test.npy"))

# 存储/读取文本文件

np.savetxt("array.txt", ar, delimiter=",")
print(np.loadtxt("array.txt", delimiter=","))
# 也可以直接 np.loadtxt('C:/Users/11244/Desktop/array.txt')

6.2作业

import numpy as np
import os
os.chdir("C:/Users/11244/Desktop")

# 作业1：创建一个10*10的整数随机数组，取值范围为0-100，并存为txt文件，用逗号分开

ar = np.random.randint(0, 100, size=(10,10))
print(ar)
np.savetxt("作业.txt", ar, delimiter=",")