python学习--numpy

1.1 n维数组-ndarray的属性

ndarray.shape 数组维度的元组
ndarray.ndim 数组维数
ndarray.size 数组中的元素数量
ndarray.itemsize 一个数组元素的长度（字节）
ndarray.dtype 数组元素的类型

1.2 ndarray的类型

2， 基本操作

2.1 生成01数组

    np.ones(shape, dtype)
    np.ones_like(a, dtype)
    np.zeros(shape, dtype)
    np.zeros_like(a, dtype)

2.2 从现有数组生成

2.2.1 生成方式

np.array(object, dtype)   # 深拷贝，从现有的数组创建

np.asarray(a, dtype)		# 浅拷贝， 相当于索引，并没有真正创建一个新的

2.3 生成固定范围的数组

2.3.1 np.linspce(start, stop, num, endpoint)

创建等差数组 — 指定数量
参数:
    start:序列的起始值
    stop:序列的终止值
    num:要生成的等间隔样例数量，默认为50
    endpoint:序列中是否包含stop值，默认为ture

# 生成等间隔的数组
np.linspace(0, 100, 11)
# 返回结果：
array([  0.,  10.,  20.,  30.,  40.,  50.,  60.,  70.,  80.,  90., 100.])

2.3.2 np.arange(start,stop, step, dtype)

创建等差数组 — 指定步长
参数
    step:步长,默认值为1

np.arange(10, 50, 2)
# 返回结果：
array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
       44, 46, 48])

2.3.3 np.logspace(start,stop, num)

创建等比数列

参数:
    num:要生成的等比数列数量，默认为50

# 生成10^x
np.logspace(0, 2, 3)

# 返回结果:

array([  1.,  10., 100.])

2.4 生成随机数组

2.4.1 使用np.random 模块

2.4.2 正态分布创建

np.random.randn(d0, d1, …, dn)

功能：从标准正态分布中返回一个或多个样本值

np.random.normal(loc=0.0, scale=1.0, size=None)

loc：float

​ 此概率分布的均值（对应着整个分布的中心centre）

scale：float

​ 此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）

size：int or tuple of ints

​ 输出的shape，默认为None，只输出一个值

np.random.standard_normal(size=None)

返回指定形状的标准正态分布的数组。

2.4.3 均匀分布

np.random.rand(d0, d1, ..., dn)
    返回[0.0，1.0)内的一组均匀分布的数。
np.random.uniform(low=0.0, high=1.0, size=None)
    功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.
    参数介绍:
        low: 采样下界，float类型，默认值为0；
        high: 采样上界，float类型，默认值为1；
        size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。
    返回值：ndarray类型，其形状和参数size中描述一致。
np.random.randint(low, high=None, size=None, dtype='l')
    从一个均匀分布中随机采样，生成一个整数或N维整数数组，
    取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

x2 = np.random.uniform(-1, 1, 100000000)
返回结果：
array([ 0.22411206, 0.31414671, 0.85655613, …, -0.92972446,
0.95985223, 0.23197723])
2.5 数组索引和切片

直接进行索引,切片
对象[:, :] -- 先行后列

1.二维数组
X[:,0]取所有行的第0个数据,第二维下标位0的所有数据，第0列（从0开始）
X[:,1] 取所有行的第1个数据
X[:,1:]第一维全部取，即所有行，列上从第一列开始取，不要第0列
X[1,:]是取第1维中下标为1的元素的所有数据，第1行（从0开始）
X[:2,1:]第一维取下标2之前的，即第2行之前（0，1两行），列上从第一列开始取，不要第0列
2.一维数组
s[i:j] 表示获取a[i]到a[j-1]
s[:-1]去掉最后一个字符
s[:-n]去掉最后n个字符
s[-2:]取最后两个字符
s[i:j:k]这种格式呢，i,j与上面的一样，但k表示步长，默认为1
s[::-1]是从最后一个元素到第一个元素复制一遍（反向）
3.三维数组
U[1,1,2]表示第一维取1，第二维取1，第三维取2
U[:,1,2]表示第一维全取，第二维取1，第三维取2
U[:,1:,2]表示第一维全取，第二维取1及1之后的所有值，第三维取2
U[:,1:,：2]表示第一维全取，第二维取1及1之后的所有值，第三维取2之前的值（0,1）
————————————————
版权声明：本文为优快云博主「萝卜吃土豆」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qq_41973536/article/details/82690242

2.6 形状修改

2.6.1 ndarray.reshape(shape, order)

返回一个具有相同数据域，但shape不一样的视图
行、列不进行互换

# 在转换形状的时候，一定要注意数组的元素匹配
stock_change.reshape([5, 4])
stock_change.reshape([-1,10])  # 数组的形状被修改为: (2, 10), -1: 表示通过待计算

2.6.2 ndarray.resize(new_shape)

修改数组本身的形状（需要保持元素个数前后相同）
行、列不进行互换

stock_change.resize([5, 4])

# 查看修改后结果
stock_change.shape
(5, 4)

2.6.3 ndarray.T

数组的转置
将数组的行、列进行互换

stock_change.T.shape
(4, 5)

2.7类型修改

2.7.1 ndarray.astype(type)

返回修改了类型之后的数组

stock_change.astype(np.int32)

2.7.2 ndarray.tostring([order])或者ndarray.tobytes([order])

构造包含数组中原始数据字节的Python字节

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[12, 3, 34], [5, 6, 7]]])
arr.tostring()

2.8 数组去重

temp = np.array([[1, 2, 3, 4],[3, 4, 5, 6]])
>>> np.unique(temp)
array([1, 2, 3, 4, 5, 6])

3 ndarray运算

3.1 逻辑运算

# 生成10名同学，5门功课的数据
>>> score = np.random.randint(40, 100, (10, 5))

# 取出最后4名同学的成绩，用于逻辑判断
>>> test_score = score[6:, 0:5]

# 逻辑判断, 如果成绩大于60就标记为True 否则为False
>>> test_score > 60
array([[ True,  True,  True, False,  True],
       [ True,  True,  True, False,  True],
       [ True,  True, False, False,  True],
       [False,  True,  True,  True,  True]])

# BOOL赋值, 将满足条件的设置为指定的值-布尔索引
>>> test_score[test_score > 60] = 1
>>> test_score
array([[ 1,  1,  1, 52,  1],
       [ 1,  1,  1, 59,  1],
       [ 1,  1, 44, 44,  1],
       [59,  1,  1,  1,  1]])

3.2通用判断函数

# np.all()

# 判断前两名同学的成绩[0:2, :]是否全及格
>>> np.all(score[0:2, :] > 60)
False

# np.any()

# 判断前两名同学的成绩[0:2, :]是否有大于90分的
>>> np.any(score[0:2, :] > 80)
True

3.3 np.where（三元运算符）

#通过使用np.where能够进行更加复杂的运算

#np.where()

# 判断前四名学生,前四门课程中，成绩中大于60的置为1，否则为0
temp = score[:4, :4]
np.where(temp > 60, 1, 0)

#    复合逻辑需要结合np.logical_and和np.logical_or使用

# 判断前四名学生,前四门课程中，成绩中大于60且小于90的换为1，否则为0
np.where(np.logical_and(temp > 60, temp < 90), 1, 0)

# 判断前四名学生,前四门课程中，成绩中大于90或小于60的换为1，否则为0
np.where(np.logical_or(temp > 90, temp < 60), 1, 0)

3.4 统计运算

min(a, axis)
    Return the minimum of an array or minimum along an axis.
max(a, axis])
    Return the maximum of an array or maximum along an axis.
median(a, axis)
    Compute the median along the specified axis.
mean(a, axis, dtype)
    Compute the arithmetic mean along the specified axis.
std(a, axis, dtype)
    Compute the standard deviation along the specified axis.
var(a, axis, dtype)
    Compute the variance along the specified axis.

4 矩阵运算

矩阵乘法api：
np.matmul
np.dot

>>> a = np.array([[80, 86],
[82, 80],
[85, 78],
[90, 90],
[86, 82],
[82, 90],
[78, 80],
[92, 94]])
>>> b = np.array([[0.7], [0.3]])

>>> np.matmul(a, b)
array([[81.8],
       [81.4],
       [82.9],
       [90. ],
       [84.8],
       [84.4],
       [78.6],
       [92.6]])

>>> np.dot(a,b)
array([[81.8],
       [81.4],
       [82.9],
       [90. ],
       [84.8],
       [84.4],
       [78.6],
       [92.6]])

np.matmul和np.dot的区别:

二者都是矩阵乘法。 np.matmul中禁止矩阵与标量的乘法。 在矢量乘矢量的內积运算中，np.matmul与np.dot没有区别。