《封号码罗》数据分析与人工智能之numpy（一）

# pycharm中的.py文件
"""
jupyter的基本使用
一、运行程序快捷键
    ctrl+Enter 运行并选中本单元
    alt+Enter 运行并在下面插入新的一行
    shift+Enter 运行并选中下一个单元，如果下面没有则创建并选中
二、插入新的代码单元
    a above 在当前上面插入一行
    b below 在当前下面插入一行
三、删除当前选中的代码单元
    双击 d 键
四、代码提示
    Tab键
五、查看函数的参数(API使用):光标需要在当前函数的参数括号里面
    在pycharm中是ctrl+p
    在jupyter中是shift+tab
六、魔法指令
    程序运行计时：%time 函数名(参数)    注意：只作用于当前行的代码

    %%time
    # 如果要多行代码，计算运行时间,注意：%%time前面不能有其他注释或代码，否则系统报错，属于系统bug问题
    函数名(参数)
    函数名(参数)

    %%timeit
    # 单行或多行代码的平均运行时间

    查看所有的魔法指令：%lsmagic
七、Markdown
    选中当前代码单元，点击左侧In部分选中，点击键盘上的M键
    Markdown编辑器，在某一行添加图片    ![](小括号填写图片名称或网络链接)
"""
import time
import numpy as np
import pandas as pd

start = time.perf_counter()
s = 100 * 100
end = time.perf_counter()
# print(f"总计耗时：{end - start}")
# 一、使用np的routines(常规)函数创建
#               数组形状        数据类型    内存存储类型C/F，先行还是先列存储
data1 = np.ones(shape=(5, 5), dtype=None, order="C")
# 多维数组            维度 行 列
data2 = np.zeros(shape=(2, 3, 4), dtype=np.float16, order="C")
# 指定其他数值的数组             填充数组的值      默认浮点数类型
data3 = np.full(shape=(3, 5), fill_value=3.14, dtype=np.float16, order="C")
# 对角线为1，其他的位置为0     单位矩阵
# 应该是一个正方形的数组
data4 = np.eye(N=5, M=None, k=0, dtype=float)
# 等差数组 np.linspace(0, 100, num=11,endpoint=Ture,retstep=False,dtype=Npne)
#                起始 结束  显示多少个数据   左闭右闭
data5 = np.linspace(0, 100, num=11)
# arange                  步长
data6 = np.arange(0, 100, 10)
#                               size=5一维数组 size=(5,5)
data7 = np.random.randint(0, 100, size=(5, 5))
# 标准正太分布
# n normal 正常，正太
# d dimession 维度      4行5列的正太分布数组
# 平均值是0，方差是1
data8 = np.random.randn(4, 5)
#                       平局值     标准差   生成数据个数   保留小数位数
data9 = np.random.normal(loc=175, scale=10, size=100).round(2)
# 平均值 data9.mean()   data9.var()方差  方差的开平方就是标准差data9.std()
# 0~1随机数组           数组内的数据个数 [0.0,1.0)左闭右开的随机
data10 = np.random.random(size=(5, 5))  # size=10为一组，值是元组为多维数组
# 二、ndarray的属性
# 4个必记参数：ndim维度 shape形状 size总长度 dtype元素类型
# data10.ndim   data10.shape    data10.size     data10.dtype
# 三、ndarray的基本操作
# 1.索引，与列表类似
# data11 = np.random.randint(0, 150, size=(4, 5), dtype=int)
data11 = np.array([[60, 123, 83, 62, 44],
                   [83, 46, 56, 26, 4],
                   [25, 48, 38, 129, 126],
                   [5, 40, 13, 123, 51]])
# data11[1, 1]  获取第二行第二列的元素
# data11[1]     获取第二行所有元素
# 2.切片
# data11[0:3] 第一行到第二行的所有数据，切片是[0,3)左闭右开原则
# data[-2:] 最后两行的数据
# data11[0:3行切, 0:3列切]
# data9[:10][::-1]  以为数组反转，先切出来10数字，再把这个10个数字的列表元素反转
# print(data9[:10][::-1])
from PIL import Image

cat = Image.open("./cat.jpg")
cat_data = np.array(cat)
# 彩色图片是三维：高度、宽度、像素（镖师不同颜色），红绿蓝三原色，搭配可以变幻出任意颜色
# uint8  u无符号的(0~255) int8是128~127
#                   宽 高不动 颜色反转
cat_data2 = cat_data[:, :, ::-1]

# 绿色的图片 红绿蓝0，1，2
ss = Image.fromarray(cat_data[:, :, [1, 0, 2]])
# 黑白的图片     变成了二维数组，颜色通道没有了，所以是黑白色
sss = Image.fromarray(cat_data[:, :, 0])
# 马赛克
import matplotlib.pyplot as plt
from matplotlib import pyplot

# plt.imshow(cat_data[::-1])  # 图片上下颠倒
# plt.imshow(cat_data[::3, ::3])  # 每个三个取一个数据
# pyplot.show() # 没有这一行不会显示图片
# 三、变形
# 使用reshape函数，注意：参数是一个元组,元组的积不能变
# print(data11.reshape(5, 4)) 对于图片来说数据会混乱
# 数据不会改变 高和宽转置了位置，图片竖立起来了，像素通道不变
# data12 = np.transpose(cat_data, axes=(1, 0, 2))
# plt.imshow(data12)
# pyplot.show()
# 四、级联  级联就相当于数据的合并
# np.concatenate()级联需要注意的点：
# 1.级联的参数是列表，一定要加中括号或小括号
# 2.维度必须相同
# 3.形状相符
# 4.（重点）级联的方向默认是shape这个tuple的第一个值所代表的维度方向
# 5.可通过axis参数改变级联的方向
# data13 = np.concatenate([data11, data11])
# print(data13)
# plt.imshow(cat_data)
data14 = cat_data[:, :160]
data15 = cat_data[:, 290:, ::-1]
# data16 = np.concatenate([data14, data15], axis=1)
data16 = np.hstack([data14, data15])  # hstack水平级联，列数增加了
# data16 = np.vstack([data14, data15])    # vstack水平级联，行数增加了（图片报错了）
# plt.imshow(data16)
# pyplot.show()
# 五、切分
# 切分是级联的逆操作
# np.split  np.vsplit   np.hsplit
# indices_or_sections=2 平均分成两份数据，这个值要能被行/列 整除
# indices_or_sections=[1, 2] 第一份数据是1行，第二份数据是一行，剩下的是第三份数据
# data17 = np.split(ary=data11, indices_or_sections=[1, 2], axis=0)
# 六、ndarray的聚合操作
data18 = np.array([[60, 123, 83, 62, 44],
                   [83, 46, 56, 26, 4],
                   [25, 48, 38, 129, 126],
                   [5, 40, 13, 123, 51]])
# axis=1列没了，横着按照行计算，合成了一列          axis=0行没了，竖着按照列计算，合成了一行
# data11.sum()  # 求和
# data11.prod()   # 累乘
# data18.argmax(axis=1)   # 求最大值的索引 13    data18.argmax(axis=1)每行最大值的索引-->[1 0 3 3]
# np.argwhere(data18 > 60)  得到该数组中所有大于60的元素的索引 np.argwhere((data18 > 60) & (data18 < 100))
# data18.ravel()把二维数组变为一维数组
# np.median(data18) 中位数 把数组从小到大排列，取中间的树 如果对象没有哪个属性，那就在模块中调用 np.median(对象)
# np.percentile(data18, q=[0, 100]) 找到一组数的分位数值 https://blog.youkuaiyun.com/weixin_40845358/article/details/84638449
# percentile()类似中位数，q=50就是中位数，这个可以自定义分位数
# data18.any() 元素都大于0为True      data18.all() 返回bool值
# np.power() 幂运算
# data18.sum()  np.nansum(data18)忽略空值
# np.corrcoef(a, b) 两个数组之间的关联，相关性系数，一般是-1到1之间的值，负相关，不相关nan，正相关

#    直方图统计 统计数据出现频次         分成五份      4到29之间的数出现了5次     29到54之间的数出现了6次 依次类推
# np.histogram(data18, bins=5)  (array([5, 6, 3, 2, 4], dtype=int64), array([  4.,  29.,  54.,  79., 104., 129.]))

# np.save("./data.npy", data18)保存为二进制的文件
# ssss = np.load("./data.npy")  读取文件

# np.savetxt("./data.txt", data18) 使用科学计数法保存的数据
# ssss = np.loadtxt("./data.txt")

# 矩阵点积（线性代数）np.dot()
# x,y,z = 2,1,5     假设有下面三个方程，要求出三个未知数的值
# x + y + z = 8
# 2x - y + z = 8
# 3x + y - z = 2
# 获取系数，组成的数组
X = np.array([[1, 1, 1], [2, -1, 1], [3, 1, -1]])
Y = np.array([8, 8, 2])  # 这个分别对应三个方程的值
# w = np.array(["x", "y", "z"])  # 这个数组是我们要求的未知数组
# Xw = Y 矩阵相乘的运算得到Y w就等于Y除以X，但是矩阵之间没有除法，需要使用逆矩阵做乘法运算
X_inv = np.linalg.inv(X)  # 得到X的逆矩阵   w = X逆矩阵 * Y
w = np.dot(X_inv, Y)  # w等于 [2. 1. 5.] 正好对应三个未知数的值

# 七、广播机制
# ndarray广播机制的两条规则：1.为缺失的维度补1 2.假定缺失元素已有值填充
m = np.ones((2, 3))  # [[1. 1. 1.],[1. 1. 1.]]
a = np.arange(3)  # [0 1 2]
# print(m + a) == np.add(m, a)           [[1. 2. 3.],[1. 2. 3.]]   每一行竖着分别对应着相加
data19 = data18.mean(axis=1)  # 每一行的平均值[74.4 43.  73.2 46.4] 列消失了
data19 = data19.reshape(4, 1)  # 变成了竖着4行1列的数组
data20 = data18 - data19  # 每一行的每个数减去对应行的数 如第一行每个数都减去74.4

# 八、排序
# 1、快速排序
# np.sort() # 默认行内数据从小到大排序，升序   在内存中生成了一个新的对象 模快排序
# data18.sort() 自身数据变了 对象排序
# 2、部分排序    np.partition(a,k) k为正时，得到最小的k个数,k为负时，得到最大的k个数,最好一维数组

s1 = time.perf_counter()
# np.savetxt("./data.txt", data18)
ssss = np.loadtxt("./data.txt")
print(ssss)
s2 = time.perf_counter()
print(f"聚合操作耗时{(s2 - s1).__round__(20)}")