数据分析课件代码 day2

01-数组的类型及形状

import numpy as np

# 创建一个数组
# arr = np.array([1, 2, 3, 4], dtype=np.float32)
# print("arr:\n", arr)
# print("arr 的元素类型：\n", arr.dtype)

# numpy里面数据类型
# numpy里面的数据类型，其实就是封装了Python里面基础的数据类型，然后还进行细致划分，之后
# 封装为np.数据类型
# 1、创建数组的时候可以通过dtype属性来指定 元素的数据类型
# 2、也可以进行强制转换
# 0 对应False  非0 对应是True
# res = np.bool(0)
# res = np.float32(5)
# print("res:\n",res)
# 3、可以通过astype来修改数据类型
# 将arr 的float32 类型转化 为int32类型
# arr = arr.astype(np.int32)
# print("arr:\n", arr)
# print("arr 的数据类型：\n", arr.dtype)

# 4、ndarray 也可以存储复合数据类型 ---了解
# # # 存储人对象---人对象 3个属性---姓名，身高，体重
# # df = np.dtype([("name", np.str, 40), ("high", np.float32), ("weight", np.float32)])
# #
# # # 创建一个存储复合数据的数组对象
# # arr = np.array([("bq", 168.5, 50.5), ("nl", 178.0, 65.0), ("yf", 172, 55)], dtype=df)
# #
# # print("arr:\n", arr)


# 形状---shape ---元组
arr = np.arange(16)
print("arr:\n", arr)
print("arr 的形状：\n", arr.shape)
print("*" * 100)

# 修改形状 ---元素的总个数必须一致
# 1、通过shape 属性进行修改
# arr.shape = (4, 4)
# print("arr:\n", arr)
# print("arr 的形状：\n", arr.shape)
# 2、可以通过reshape来修改数组的形状
# reshape 会返回一个新的数组，需要去接收
arr = arr.reshape((4,4))
print("arr:\n", arr)
print("arr 的形状：\n", arr.shape)

02-数组的索引

import numpy as np

# # 创建一个一维数组
# arr = np.arange(1, 10)
# print("arr:\n", arr)
#
# # 使用单独的下标 会造成降低维度
# # 获取 arr 里面的 6 这个元素 --下标
# print("获取arr里面的6：", arr[5])
# # 获取 arr 里面的 9 这个元素 --下标
# print("获取arr里面的9：", arr[-1])
#
# # 获取 arr 里面的 6 9这两个元素 ---下标列表
# print("获取arr里面的6和9 ：", arr[[5, -1]])
#
# # 获取arr 里面的 6 这个元素 ---切片
# print("获取arr里面的6：", arr[5:6])
#
# # 获取 arr 里面的 9 这个元素 --切片
# print("获取arr里面的9：", arr[-1:])
#
# # 获取 arr 里面的 6 9这两个元素 ---切片
# print("获取arr里面的6和9 ：", arr[5::3])

# 创建一个二维数组
# arr = np.arange(1, 17).reshape((4, 4))
# print("arr:\n", arr)

# 使用单独的下标 会进行降低维度
# 使用切片不降低维度
# 使用下标列表---可以理解为 将多个下标的值取出来，然后组合起来---一维

# 获取arr里面的 6 这个元素 --下标
# print("获取arr里面的6：", arr[1, 1])
# 获取arr 里面的 11这个元素 --下标
# print("获取arr里面的11 :", arr[2, 2])

# 获取 arr 里面的 6 和 11 这两个元素 --下标列表
# 找的 行列上一一对应位置的元素
# print("获取arr 里面的6 和11 这两个元素：", arr[[1, 2], [1, 2]])

# 获取 arr 里面的 8 和 15 这两个元素 ---下标列表
# print("获取arr 里面的8 和15 这个两个元素：", arr[[1, 3], [3, 2]])

# 获取arr里面的 6 这个元素 --切片
# print("获取arr 里面的6 这个元素：", arr[1:2, 1:2])
# 获取arr 里面的 11这个元素 --切片
# print("获取arr里面的11 :", arr[2:3, 2:3])

# 获取 arr 里面的 6 和 11 这两个元素  ----下标列表
# print("获取arr 里面的6 7 和10 11 这两个元素：", arr[1:3, 1:3])  # 获取的 一块元素

#  获取 11 12  15 16 这4个元素
# print("获取 11 12  15 16 这4个元素", arr[2:, 2:])

# 使用下标列表 --获取 11 12  15 16 这4个元素
# print("获取 11 12  15 16 这4个元素", arr[[2, 2, 3, 3], [2, 3, 2, 3]])

#  获取4 8 12 16 这一列
# print("获取4 8 12 16 这一列", arr[:, 3:])
# print("获取4 8 12 16 这一列", arr[:, 3])

# 三维数组 ---arr[块,行,列]
# n维数组 ---arr[n-1个逗号]将N个维度划分开来，然后在对应的维度进行索引


# 创建一个二维数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# bool 数组索引
# 创建一个bool数组
bool_index = np.array([0, 1, 1, 0], dtype=np.bool)
print('bool_index:\n', bool_index)

# 利用bool数组进行 索引 arr ---如果为True 就选中，如果为False就干掉
# bool数组长度必须和 你要索引的维度的数量必须相等
# print(arr[bool_index, :])
# print(arr[:, bool_index])
print(arr[bool_index, bool_index])  # 参考前后都是下标列表理解

03-数组的展开

import numpy as np

# 创建一个二维数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# 将二维转化为1维
# arr = arr.reshape((16,))
# print("arr:\n", arr)

# arr.shape = (16,)
# print("arr:\n", arr)

# 数组的展开
# flatten  -- ravel
# ---功能没有区别
# flatten ---返回一个拷贝的内存
# ravel ----返回原来的引用或者视图
# np.ravel(arr,"C")
# arr = arr.flatten('C')
# arr = arr.flatten('F')
# arr = arr.ravel('C')
# arr = arr.ravel('F')

# print("arr:\n", arr)

04-数组的合并与拆分

import numpy as np

# # 创建两个二维数组
# arr1 = np.array([[9, 0], [8, 9]])
# arr2 = np.arange(4).reshape((2, 2))
#
# print("arr1:\n", arr1)
# print("arr2:\n", arr2)

# 将arr2 拼接到 arr1 下边 ---垂直
# res = np.vstack((arr1, arr2))
# print("res:\n",res)

# 将arr2 拼接到 arr1 右边 --水平
# res = np.hstack((arr1,arr2))
# print("res:\n",res)

# axis --->指定拼接的轴
# res = np.concatenate((arr1, arr2),axis=0)
# res = np.concatenate((arr1, arr2),axis=1)
# print("res:\n",res)


# 创建一个数组
arr = np.arange(1, 17).reshape((4, 4))
print("arr:\n", arr)

# 拆分的时候，必须能整除，必须平均拆分

# 拆分
# 水平拆分----把横着的列打断
# res = np.hsplit(arr,2)
# print("res:\n",res)

# 垂直拆分 ---把竖着的行 打断
# res = np.vsplit(arr,2)
# print("res:\n",res)

# 在行的方向拆分
# res = np.split(arr, 2, axis=0)
# 在列的方向拆分
# res = np.split(arr, 2, axis=1)
# print("res:\n", res)

# 拆分为 三部分[:1],[1:3],[3:]
# res = np.split(arr, [1, 3], axis=0)
# print("res:\n", res)

# 将数组拆分 第一列一部分 ，其他的列为1部分 ---索引获取指定的部分
res1 = arr[:, :1]
res2 = arr[:, 1:]
print("res1:\n", res1)
print("res2:\n", res2)

05-矩阵的创建

import numpy as np

# 创建矩阵 ---矩阵是二维的，也只能是二维
# mat 与 asmatrix 一样，与matrix 相比少了一个拷贝的过程。 ---推荐
# mat 可以将特殊字符串、列表嵌套、二维数组转化为矩阵
# m1 = np.mat("1 2 3;4 5 6;7 8 9") #  <class 'numpy.matrixlib.defmatrix.matrix'>
# m1 = np.mat([[1, 2], [3, 4]])
# m1 = np.mat(np.array([[1, 2], [3, 4]]))
# print("m1:\n", m1)
# print("m1 的类型：\n", type(m1))
# print("m1 的维度：\n",m1.ndim)
# print(m1[0,:]) # 矩阵里面使用下标不降低维度

# 使用matrix创建矩阵
# matrix 可以将特殊字符串、列表嵌套、二维数组转化为矩阵
# m1 = np.matrix("1 2 3;4 5 6;7 8 9")
# m1 = np.matrix([[1, 2], [3, 4]])
# m1 = np.matrix(np.array([[1, 2], [3, 4]]))
# print("m1:\n", m1)
# print("m1 的类型：\n", type(m1))

# 使用bmat来合成矩阵
# bmat 可以直接将二维数组转化为矩阵
# m1 = np.bmat(np.array([[1, 2], [3, 4]]))
# m1 = np.bmat([[1, 2], [3, 4]]) # 错误的
# m1 = np.bmat("1 2 3;4 5 6;7 8 9") # 错误的
# print("m1:\n", m1)
# print("m1 的类型：\n", type(m1))

m1 = np.mat(np.array([[1, 2], [2, 1]]))
m2 = np.mat(np.arange(4).reshape((2, 2)))
print("m1:\n", m1)
print("m2:\n", m2)

# 使用矩阵来组合矩阵
# 也可以使用数组来组合矩阵
# m = np.bmat('m1 m2;m2 m1')
# m = np.bmat([[m1, m2], [m2, m1]])
# print("m:\n", m)

06-矩阵的运算及属性

import numpy as np

# 创建两个矩阵
m1 = np.mat(np.array([[1, 3], [4, 5]]))
m2 = np.mat(np.array([[1, 2], [1, 3]]))
print("m1:\n", m1)
print("m2:\n", m2)

# 矩阵 与数的相乘 ---矩阵中的每一个元素与数进行相乘
# m3 = m1 * 2
# print("m3:\n", m3)
# print("m3 的类型：\n", type(m3))

# 矩阵与矩阵的相加减 ---对应位置元素的相加减----必须是同型矩阵
# m3 = m1 + m2
# m3 = m1 - m2
# print("m3:\n", m3)
# print("m3 的类型：\n", type(m3))

# 矩阵的相乘 ---规则：左矩阵的列数必须等于右矩阵的行数，才能进行相乘，返回一个左矩阵行数、右矩阵列数的矩阵
# m1 ---(2,2)
# m2 ---(2,2)
# m3 ---(2,2)
# m3 = m1 * m2
# m3 = np.matmul(m1, m2)
# m3 = np.dot(m1, m2)
# print("m3:\n", m3)
# print("m3 的类型：\n", type(m3))

# 同型矩阵对应位置元素的相乘
# m3 = np.multiply(m1,m2)
# print("m3:\n", m3)
# print("m3 的类型：\n", type(m3))

# 获取矩阵的属性
# print("m1 的转置为：\n",m1.T)
# print("m1 的共轭转置为：\n",m1.H)
# 可以通过np.mat 将数组转化为矩阵，也可以通过m1.A将矩阵转化为数组
# print("m1 的视图为：\n", m1.A)
# print("m1 的视图的类型为：\n", type(m1.A))
# print("m1 的逆矩阵为：\n",m1.I)
# print("m1 * m1 的逆 的值为：\n",np.matmul(m1,m1.I))

07-数组的全通用函数

import numpy as np

"""
数组的全通用函数---对数组的每一个元素都进行操作的函数 ----数组的形状必须是一样的
"""
# 创建两个数组
arr1 = np.array([[2, 1], [5, 6]])
arr2 = np.array([[0, 1], [1, 0]])
print("arr1:\n", arr1)
print("arr2:\n", arr2)
print("*" * 100)
# 数组的四则运算 --- + - * / ** ---对应位置进行运算
# print("数组相加：\n", arr1 + arr2) # 对应位置元素进行相加
# print("数组相减：\n", arr1 - arr2)  # 对应位置元素进行相减
# print("数组相乘：\n", arr1 * arr2) # 对应位置元素进行相乘
# print("数组相除：\n", arr2 / arr1) # 对应位置元素进行相除，注意：分母不能为0
# print("数组相幂：\n", arr1 ** arr2)  # 对应位置元素进行求幂


# 数组的比较运算 < > <= >= == != ---对应位置元素进行相比，如果满足条件，返回T,如果不满足条件，返回F，最终组合返回一个bool数组
# 返回bool数组
# print("arr1 > arr2 :\n", arr1 > arr2)
# print("arr1 != arr2:\n", arr1 != arr2)
# print(" arr1 >= arr2 :\n",arr1 >= arr2)
# print(" arr1 == arr2 :\n", arr1 == arr2)
print(" arr1 < arr2 :\n", arr1 < arr2)

# 数组的逻辑运算  ---返回bool值
# ap.all  相当于and  只有所有条件都满足，才返回True
# print(np.all(arr1 >= arr2))
# print(np.all(arr1 > arr2))
# np.any  相当于or, 只要有一个满足条件，就返回True
# print(np.any(arr1 == arr2))
# print(np.any(arr1 < arr2))

08-广播机制

import numpy as np

"""
广播机制---不同形状之间的数组进行算术运算需要满足的规则
"""

# 创建两个不同形状的数组
arr1 = np.array([[1, 2], [2, 1]])  # shape---(2,2)
arr2 = np.array([3, 4])  # shape --(2,)---->(1,2)
arr3 = np.array([[1, 2, 3], [4, 5, 6]])  # shape (2,3)
arr4 = np.array([[1], [4]])  # shape (2,1)
print("arr1:\n", arr1)
print("arr2:\n", arr2)

# arr1 + arr2 ???
print("arr1 + arr2 :\n", arr1 + arr2)

# arr1 + arr3 ??? ---不可以---不满足 规则3
# print(arr1 + arr3)
print('*' * 100)

print(arr1 + arr4)

# arr1 -->shape (1,2,3,4,5,5,6,7)
# arr2 --->shape (4,1,5,6,1) --->(1,1,1,4,1,5,6,1)  可以进行运算


# arr1 --->shape(4,1,2,5)
# arr2 --->shape (2,5,1) ---> (1,2,5,1) #不可以进行运算

09-数组的保存与读取

import numpy as np

# 二进制形式保存
# 创建数组
arr = np.arange(16).reshape((4, 4))
print("arr:\n", arr)
# arr1 = np.array([1, 2, 3, 4, 5])
# print("arr1 :\n", arr1)
# 保存起来---以二进制形式
# 参数1 --保存的路径+ 名称，后缀名可以省略，默认保存为.npy文件
# 参数2 ---需要保存的数组
# 以二进制保存单个数组
# np.save("./arr",arr)
# print("保存完毕")
# 加载保存的单个数组
# 参数 路径+名称，此时，后缀名不能省略
# res = np.load("./arr.npy")
# print(res)

# 以二进制的形式保存多个数组
# 参数1 路径+名称，此时，后缀名可以省略，默认保存为.npz为结尾的文件
# 接下来的参数 ---需要保存数组
# np.savez("./arr", arr, arr1)
# print("保存完毕")


# 保存的时候以键值对的形式的进行保存的
# 加载.npz文件
# res = np.load("./arr.npz")
# print("res:\n",res)

# for tmp in res:
#     print(tmp)
# 根据键值 取保存的数组
# a = res["arr_0"]
# b = res["arr_1"]
# print("a:\n",a)
# print("b:\n",b)


# 也可以指定 保存的key 来进行保存数组
# 指定key 进行保存
# np.savez("./arr_key", k1=arr, k2=arr1)
# print("保存完毕")

# 加载arr_key.npz文件
# res = np.load("./arr_key.npz")
# for tmp in res:
#     print(tmp)
# k1 = res["k1"]
# k2 = res['k2']
# print("k1:\n",k1)
# print("k2:\n",k2)



# 文本形式保存
# 参数1 保存路径+名称
# 参数2 需要保存的数组
# fmt 保存的格式
# delimiter --分隔符
# np.savetxt("./arr.txt",arr, fmt='%d',delimiter=",")
# print("保存完毕")

# 加载文本类型的数组
# res = np.loadtxt("./arr.txt",dtype=int,delimiter=",")
# print("res:\n",res)

# 可以读取含有缺失值的数组，默认会补上一个与数组不同的值
# res = np.genfromtxt("./arr.txt",dtype=int,delimiter=",")
# print("res:\n",res)

10-数组的排序

import numpy as np

# 数组的排序，自己排自己，与别的元素无关
# 创建一个一维数组
arr = np.array([5, 7, 2, 1, 0])
# arr = np.array([[2, 1, 0], [5, 0, 1], [0, 2, -1]])
# print(arr)
# 直接排序 --sort --对原数组直接进行排序
# arr.sort(axis=1)
# arr.sort(axis=0)
# print("arr排序之后的结果：\n", arr)

# 间接排序
# argsort  ---返回排序之后结果所对应的元素在原来位置的下标
# res = np.argsort(arr,axis=0)
# print("res:\n",res)

# lexsort ---借助别人的规则，来给自己排序
# a = np.array([3, 2, 6, 4, 5])
# b = np.array([50, 30, 40, 20, 10, ])
# c = np.array([400, 300, 600, 100, 200])

# 按照最后一个元素的规则进行排序，返回最后一个元素排序之后结果所对应的元素原来的下标
# res = np.lexsort([a,b,c],axis=0)
# res = np.lexsort([a,c,b],axis=0)
# res = np.lexsort([b, c, a], axis=0)
#
# print(res)
#
# b_sorted = [b[i] for i in res]
# print('b_sorted:\n', b_sorted)