Python 科学计算库 Numpy

注意一点数组运算时的 broadcast(广播机制)

import numpy as np
import matplotlib.pyplot as plt
import time
import random


score = np.array([
     [1, 2, 3, 4, 5],
     [6, 7, 8, 9, 9],
     [3, 2, 3, 2, 1],
     [1, 3, 1, 3, 5],
], dtype = "int64") # 指定数据类型

# 输出的是ndarray的属性
print(score.shape) # 返回数组的形状，比如几行几列
print(score.dtype) # 返回数组中存储的数据类型
print(score.ndim)  # 返回数组的维数
print(score.size)  # 返回数组中元素的个数
print(score.itemsize) # 返回存储数据所在字节数

print("-----------")

a = np.array([ [1,2,3], [3, 4, 5] ])   # 二维
b = np.array([1.0,2,3,4,5]) # 一维
print("b的数据类型是%", b.dtype)
c = np.array([  # 三维(2, 2, 3)
    [
        [1, 2, 3],
        [4, 5, 6],
    ],
    [
        [7, 8, 9],
        [3, 5, 2],
    ],
])

# print(c)
print(c.shape)
print(c.dtype)
print(c.size)
print(c.ndim)

print("-----------")

# shape可以用元组表达，也有可以用列表
zero = np.zeros(shape = (3, 4), dtype = "int64")
zero = np.zeros(shape = [3,4], dtype = "int64")
print(zero)

one = np.ones(shape = (3,4), dtype = "int64")
print(one)

# 从现有数组中生成数组
print("-------------")
data1 = np.array(score)  # 深拷贝
data2 = np.asarray(score)  # 浅拷贝
data3 = np.copy(score)  # 深拷贝

score[2,2] = 1000;
print("data1:")
print(data1)
print("data2:")
print(data2)
print("data3")
print(data3)


# 生成固定范围的数组，注意两种方法的有不同, 一个是双闭区间, 一个是左闭右开
print("-------------")
data4 = np.linspace(0, 100, 2)  # [0, 100]内 等距离为10的数据
print(data4)
data5 = np.arange(0, 100, 5)  # [0, 100)内 步长为5的数据
print(data5)

# 生成随机数组
print("--------------")
# 生成一组均匀分布
data = np.random.uniform(low = 1, high = 10, size = 10000)
print(data)

# plt.figure(figsize = (60, 40), dpi = 10)
# plt.hist(data, 1000)
# plt.show()


# 正态分布
# loc是均值，scale是标准差，size是生成数据的个数
data = np.random.normal(loc=1.75, scale=0.1, size=10000000)
# plt.figure(figsize=(20, 8), dpi=30)
# plt.hist(data, 1000)
# plt.show()

# 数组操作
# 案例：模拟生成8只股票两周的交易日涨跌幅数据
data = np.random.normal(loc=0, scale=1, size=(8, 10))
# 获取第一个股票的前三个交易日的涨跌幅数据
print(data[0, 0:3])
# 形状修改，行列反转
data.reshape(10, 8) #返回一个新的，并不修改data本身，只是修改形状，把原始数据按顺序进行分割，并没有转置
print(data.shape)
data.resize((10, 8))  # 没有返回值，修改data本身，效果和reshape是一样的
print(data)
data.resize((8, 10))

print(data.T)  # data.T是数组转置操作


# 数组类型修改
data.astype("int32")
print(data)
# print(data.tostring())

#数组去重

data = np.array([[1,2,3,4,], [1, 3, 5, 6]])
print(np.unique(data))
print(data)
print(data.flatten())   # 降维
print(set(data.flatten()))


# 数组运算
print("-----------")

# 逻辑运算
data = np.random.normal(loc=0, scale=1, size=(8, 10))
print(data > 0.5)
# data[data > 0.5] = 0.1 #布尔索引
print(data)

print(np.all(data[:, :] > 0))  # 只有全是true才返回true
print(np.any(data[:, :] > 0))  # 只要有一个true就返回true

#三元运算符
# 返回一个新的对象 True的位置赋值为1， false的位置赋值为0
print(np.where(data > 0, 1, 0))
print(data)

# and or
print(np.logical_and(data > 0.5, data < 1))
print(np.logical_or(data < 0.5, data > 1))


# 统计运算
# 最小值，最大值，平均值，中位数，方差，标准差
# 对应函数名 min, max, mean, median, var, std
# np.函数名() or ndarray.方法名()
print("--------------")
temp = data[:5, :5]
print(temp)
print(temp.max())   # 求的是整体最大值  返回的是值
print(temp.max(axis=0))     # 求的是每一列的最大值
print(np.max(temp, axis=1))  # 求的是每一行的最大值

print(temp.argmax())    #  返回的是下表的索引，但是是单值索引，先行后列
print(np.argmax(temp, axis=1))  # 返回的是最大值所在的索引值


# 数组与数的运算
print("------------")
a1 = np.array([
    [1, 2, 3, 1, 4],
    [5, 6, 7, 8, 9],
])

# print(a1+1)
# print(a1/10)
# print(a1*10)


# 数组与数组的运算需要满足广播机制


#矩阵运算
#两种存储方法 分别是 ndarray二维数组和 matrix数据结构

# matrix
data_mat = np.mat([
    [80, 86],
    [82, 80],
    [85, 78],
    [90, 90],
    [86, 82],
    [82, 90],
    [78, 80],
    [92, 94],
])
weight_mat = np.mat([
    [0.3],
    [0.7],
])
print(type(data_mat))
print(data_mat * weight_mat )


# ndarray
data = np.array([
    [80, 86],
    [82, 80],
    [85, 78],
    [90, 90],
    [86, 82],
    [82, 90],
    [78, 80],
    [92, 94],
])
weight = ([
    [0.3],
    [0.7],
])
print()
print(data @ weight)    # 相乘
print(np.dot(data, weight))
# weight_mat = np.mat(weight)
# print(weight_mat)
# print(np.matmul(data, weight))
# print()


# 合并
print("--------------")
a = np.array((1, 2, 3))
b = np.array((2, 3, 4))
print(np.hstack((a, b)))    # 水平合并
print(np.vstack((a, b)))    # 竖直合并

a = np.array([
    [1],
    [2],
    [3],
])
b = np.array([
    [2],
    [3],
    [4],
])

print(np.hstack((a, b)))
print(np.vstack((a, b)))

print(np.concatenate((a, b), axis = 0))  # 指定合并 0是竖直，1是水平
print(np.concatenate((a, b), axis = 1))

# 分割
print("------------------")
x = np.arange(9.0)
print(x)
print(np.split(x, 3))   # 分成三个
x = np.arange(0, 20, 2)
print(x)
print(np.split(x, [3, 5, 6, 10]))   # 分割到第3个，第五个，第6个，第10个



# IO操作和数据处理
print("-----------")
# 读入数据，字符串无法读入
# 缺失值处理 数据较多时直接删除缺失值所在的行，数据较少时用插补发，求所在列的平均值或中位数代替

data = np.genfromtxt("C:\\Users\zclsh\Desktop\\test.txt", delimiter=",")
print(data)

#处理缺失值逻辑
def fill_nan_by_column_mean(t):
    for i in range(t.shape[1]):
        # 计算nan的个数
        nan_num = np.count_nonzero(t[:, i][t[:, i] != t[:, i]])
        if nan_num > 0:
            now_col = t[:, i]
            # 求和
            now_col_not_nan = now_col[np.isnan(now_col) == False].sum()
            # 和/个数
            now_col_mean = now_col_not_nan / (t.shape[0] - nan_num)
            # 赋值给now_col
            now_col[np.isnan(now_col)] = now_col_mean
            # 赋值给t, 即更新t的当前列
            t[:, i] = now_col
    return t

fill_nan_by_column_mean(data)
print(data)