numpy创建数组

import numpy as np


# 1). 创建数组: a, b, c创建的数组相同， 任选一种;
a = np.array([1, 2, 3, 4, 5])
b = np.array(range(1, 6))
c = np.arange(1, 6)

print(a, b, c)
#
# # 2). 查看numpy创建的数组类型
print(type(a))
print(type(b))
print(type(c))

#
# 3). 查看数组存储的数据类型, 常见的数据类型还有哪些?
print(a.dtype)   # 为什么是int64？ 因为硬件架构是64位;


# 4). 制定创建的数组的数据类型
d = np.array([1.9, 0, 1.3, 0], dtype=float)
print(d, d.dtype)
#
# 5). 修改数组的数据类型
e = d.astype('int64')   # 里面可以是数据类型， 也可以是数据代码;int64---i1
print(e, e.dtype)

# 6). 修改浮点数的小数点位数
# 随机创建一个三行四列的数组;
f = np.random.random((3, 4))
print(f)

# 修改浮点书的小数位数为3位
g = np.round(f, 3)
print(g)

矩阵的转置

import numpy as np

data = np.random.random((3, 4))

# 转换数据结构 # 2,6
data = data.reshape((2, 6))

print(data)
print("转置: ", data.T)
print("转置: ", data.transpose())
print("转置: ", data.swapaxes(1, 0))

numpy的索引和切片

import numpy as np
a = np.arange(12).reshape((3, 4))

print(a)

# *****************取单行或者单列*********************
# 取第2行;
print(a[1])
# 取第3列;
print(a[:, 2])
# 获取第2行3列的数据
print(a[1, 2])



# *****************取连续行或者列*********************
# 取第2行和第3行;
print(a[1:3])

# 取第3列和第4列
print(a[:, 2:4])

# 行： 1和2   列: 2
print(a[0:2, 1:2])



# *****************取不连续的行或者列*********************
# 行： 1和3   列: all 获取第一行和第三行的所有元素
print(a[[0, 2], :])
# 行: all   列: 1, 4
print(a[:, [0, 3]])
# 行： 1 , 3   列： 1 4  获取第一行第一列的元素， 和第三行第4列的元素
print("*"*10)
print(a[[0, 2], [0, 3]])

numpy中数值的修改

import numpy as np

# 执行行和指定列的修改
t = np.arange(24).reshape((4, 6))
print(t)
#行： all, 列: 3,4
t[:, 2:4] = 0
print(t)

# 布尔索引
print(t < 10)
#
t[t < 10] = 100
print(t)

t[t > 20] = 200
print(t)


# numpy的三元运算符 t<100?0:10
t1  = np.where(t < 100, 0, 10)
print(t)
print(t1)

花式索引

"""
花式索引
    花式索引指的是利用整数数组进行索引。

    花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；
    如果目标是二维数组，那么就是对应下标的行。

    花式索引跟切片不一样，它总是将数据复制到新数组中。
"""

import numpy as np
# 传入顺序索引数组
x = np.arange(32).reshape((8, 4))
print(x)
print(x[[4, 2, 1, 7]])

# 传入倒序索引数组
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])

# 传入多个索引数组（要使用np.ix_）
"""
原理：np.ix_函数就是输入两个数组，产生笛卡尔积的映射关系
将数组[1,5,7,2]和数组[0,3,1,2]产生笛卡尔积，就是得到
(1,0)，(1,3)，(1,1)，(1,2)；(5,0)，(5,3)，(5,1)，(5,2)；(7,0)，(7,3)，(7,1)，(7,2)；(2,0)，(2,3)，(2,1)，(2,2)；
"""
x=np.arange(32).reshape((8,4))
print(x)
print (x[np.ix_([1,5,7,2],[0,3,1,2])])

数组形状修改

"""
    reshape	不改变数据的条件下修改形状
         numpy.reshape(arr, newshape, order='C')
         order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。
    flat	数组元素迭代器

    flatten	返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
    ravel	返回展开数组
"""

import numpy as np

print("****************************************flat********************************")
a = np.arange(9).reshape(3, 3)
print('原始数组：')
for row in a:
    print(row)

# 对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print('迭代后的数组：')
for element in a.flat:
    print(element)

#
print("*********************************flatten**************************************")
a = np.arange(8).reshape(2, 4)

print('原数组：')
print(a)
print('\n')
# 默认按行

print('展开的数组：')
print(a.flatten())
print('\n')

print('以 F 风格顺序展开的数组：')
print(a.flatten(order='F'))


print("*********************************ravel*************************************")
a = np.arange(8).reshape(2, 4)

print('原数组：')
print(a)
print('\n')

print('调用 ravel 函数之后：')
print(a.ravel())
print('\n')

print('以 F 风格顺序调用 ravel 函数之后：')
print(a.ravel(order='F'))

数组拼接，分割

"""
concatenate	连接沿现有轴的数组序列
stack	沿着新的轴加入一系列数组。
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）

"""

import numpy as np


print("******************** concatenate ****************")
a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
print('\n')

b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
print('\n')

# 两个数组的维度相同
# x轴和y轴， 1轴和0轴
print('沿轴 0 连接两个数组：')
print(np.concatenate((a, b)))
print('\n')

print('沿轴 1 连接两个数组：')
print(np.concatenate((a, b), axis=1))




print("*************************stack*********************************")
a = np.array([[1, 2], [3, 4]])

print('第一个数组：')
print(a)
print('\n')
b = np.array([[5, 6], [7, 8]])

print('第二个数组：')
print(b)
print('\n')

print('沿轴 0 堆叠两个数组：')
print(np.stack((a, b), axis=0))
print('\n')

print('沿轴 1 堆叠两个数组：')
print(np.stack((a, b), axis=1))

print("**************************************hstack + vstack*************************************")
a = np.array([[1, 2], [3, 4]])

print('第一个数组：')
print(a)
print('\n')
b = np.array([[5, 6], [7, 8]])

print('第二个数组：')
print(b)
print('\n')

print('水平堆叠：')
c = np.hstack((a, b))
print(c)
print('\n')


print('竖直堆叠：')
c = np.vstack((a, b))
print(c)
print('\n')

"""
    split	将一个数组分割为多个子数组
        numpy.split(ary, indices_or_sections, axis)
    hsplit	将一个数组水平分割为多个子数组（按列）
    vsplit 	将一个数组垂直分割为多个子数组（按行）
"""

import numpy as np


print("**********************split******************************")
a = np.arange(9)
print('第一个数组：')
print(a)
print('\n')

print('将数组分为三个大小相等的子数组：')
b = np.split(a, 3)
print(b)
print('\n')

print('将数组在一维数组中表明的位置分割：')
b = np.split(a, [3, 7])
print(b)



print('******************hsplit*****************')
harr = np.arange(12).reshape((3, 4))
print('原array：')
print(harr)

print('横向拆分后：')
print(np.hsplit(harr, 2))



print("***************************vsplit****************************")

a = np.arange(12).reshape(4, 3)

print('第一个数组：')
print(a)
print('\n')

print('竖直分割：')
b = np.vsplit(a, 2)
print(b)

数组元素的添加与删除

"""
    resize	返回指定形状的新数组
    append	将值添加到数组末尾
    insert	沿指定轴将值插入到指定下标之前
    delete	删掉某个轴的子数组，并返回删除后的新数组
    unique 	查找数组内的唯一元素
            arr：输入数组，如果不是一维数组则会展开
            return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
            return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

"""
import numpy as np

print('***************append****************')
a = np.array([[1, 2, 3], [4, 5, 6]])

print('第一个数组：')
print(a)
print('\n')

print('向数组添加元素：')
print(np.append(a, [7, 8, 9]))
print('\n')

print('沿轴 0 添加元素：')
print(np.append(a, [[7, 8, 9]], axis=0))
print('\n')

print('沿轴 1 添加元素：')
print(np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1))

print('******************************insert****************************************')
a = np.array([[1, 2], [3, 4], [5, 6]])

print('第一个数组：')
print(a)
print('\n')

print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.insert(a, 3, [11, 12]))
print('\n')

print('传递了 Axis 参数。 会广播值数组来配输入数组。')
print('沿轴 0 广播：')
print(np.insert(a, 1, [11], axis=0))
print('\n')

print('沿轴 1 广播：')
print(np.insert(a, 1, 11, axis=1))

print('***********************delete******************************************')
a = np.arange(12).reshape(3, 4)

print('第一个数组：')
print(a)
print('\n')

print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.delete(a, 5))
print('\n')

print('删除第二列：')   # axis=1, 水平方向， 将每一行的第1个索引元素删除;
print(np.delete(a, 1, axis=1))
print('\n')

print('删除第二行：')     # axis=0, 竖直方向, 将每一列的第第一个索引删除'
print(np.delete(a, 1, axis=0))
print('\n')

print('包含从数组中删除的替代值的切片：')
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
"""
np.s_ 为阵列建立索引元组的一种更好的方法。 返回的时slice对象;
也可以使用`Slice()‘加上一些特殊的对象来完成所有这些操作但这个版本更简单，因为它使用了标准的数组索引语法。
"""
print(np.delete(a, np.s_[::2]))


print("删除二维数组")
data = np.arange(12).reshape((3, 4))
print("数组元素:")
print(data)
# 行：  列: 2列开始
print(np.delete(data, np.s_[::2], axis=0))
print(np.delete(data, np.s_[::2], axis=1))


#
#
# print('****************************unique**********************************************')
#
# a = np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9])
# #
# print('第一个数组：')
# print(a)
# print('\n')
#
# print('第一个数组的去重值：')
# u = np.unique(a)
# print(u)
# print('\n')
#
# print('去重数组的索引数组：')
# u, indices = np.unique(a, return_index=True)
# print(indices)
# print('\n')
#
# print('返回去重元素的重复数量：')
# u, indices = np.unique(a, return_counts=True)
# print(u)
# print(indices)

numpy的统计函数

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
numpy.percentile() 百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。
numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。   average()
np.std()    标准差是一组数据平均值分散程度的一种度量。
    标准差公式如下：std = sqrt(mean((x - x.mean())**2))
np.var()    统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。
     标准差是方差的平方根。