Numpy Pandas

数据分析 : 是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来,总结出所研究对象的内在规律.

数据分析三剑客 -  Numpy Pandas Matplotlib

# Numpy 基于一维或多维的数组    数组开辟的内存是连续的  数据容器 (是python的一个扩展程序库,支持大量的维度数组和矩阵运算,此外也针对数组原酸提供大量的数学函数库)
import numpy as np
ndarray 对象是用来存放同类型元素的多维数组,其中每个元素在内存中都有相同存储大小的区域

# array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0) 数据源 默认整型
arr1 = np.array([1,2,3,4,5])    一维
arr1 = np.array([[1,2,3],[3,4,"two"]])  二维
# 传进来的列表中包含了不同的数据类型,则统一为统一类型,优先级:str>float>int

# 加载一张图片进来
import matplotlib.pyplot as plt
img_arr = plt.imread('./toy.jpg') #读图片 图像
# img_arr     # 三维数组
plt.imshow(img_arr)    # 显示图片
img_arr = img_arr-10
plt.imshow(img_arr)
img_arr.shape   #数组的形状(px,px,维度)
--------------------------------------
np routines 函数创建
np.ones(shape,dtype,order)  # 最后是排序
np.zeros(shape,dtype,order) # float
np.full(shape=(5,6,3),fill_value=12) # 几行几列 几纬度  数据填充
np.linspace(0,100,10)  # 基于等差数列的一位数组(不能,参数没有shape)  最后是个数
np.arange(0,100,3)     # 一维数组  [起止)步长
---------------------------------------

# 随机性固定 随机因子
　np.random.seed(10) #固定时间种子 产生的随机数就固定下来了
　np.random.randint(0,100,size=(6,7)) #[ )

　np.random.randn(d0,d1,d2 .. .. dn) #高斯分布 标准正态分布

　np.random.random(size=(4,5)) #[0.0, 1.0)半闭合

　np.eye(5) 返回一个二维数组，对角线上是1，其他地方是0. 2-D float

#  ndarray的属性
ndim 维度 
shape 形状(各维度的长度)
size  总长度
dtype 元素类型
img_arr.ndim    3
img_arr.size    114027
img_arr.shape  (191, 199, 3)
img_arr.dtype  dtype('uint8') 
type(img_arr)  numpy.ndarray

ndarray 索引  一维与列表一样,多维时候同理
arr1[0][0]
--------- 切片---------------
np.random.seed(1)
arr = np.random.randint(0,100,size=(5,6))
arr[:2]   # 获取前两行
arr[:,:2]    # 获取前两列     #(行,列,三维度)  左行右列
arr[0:2,:2]   # 前2行/2列
---------- 倒叙 ------------
# arr[::-1]    行倒叙
# arr[:,::-1]    列倒序
# arr[::-1,::-1]  行列都倒叙

# 图片各种翻转
plt.imshow(img_arr)
plt.imshow(img_arr[:,::-1,:])  # 左右转 列倒
plt.imshow(img_arr[::-1,:,:])   # 上下转 列倒序
plt.imshow(img_arr[::-1,::-1,::-1]) # 全倒序

变形 ?   reshape  参数是tuple
一维变二维   -1是自动计算
二维变一维   一维

# 合并三张照片-------------------------------
import matplotlib.pyplot as plt
img_arr = plt.imread('./toy.jpg')
im3 = np.concatenate((img_arr,img_arr,img_arr),1)  #级联
im9 = np.concatenate((im3,im3,im3),0)\ 
plt.imshow(im9)
# -- 切图 ----------------------------------
plt.imshow(img_arr)
plt.imshow(img_arr[40:110,50:133,:])

# 求和
a1.sum(axis=0) #a.sum(axis=None, dtype=None, out=None, keepdims=False)
# 排序
np.sort(a1,axis=1)  #不改变输入
ndarray.sort() 本地处理 不占用空间 但改变输入

级联需要注意:
    参数是列表: 一定要加[]  ()
    维度必须相同
    形状相符  维度一致时,横向级联行数一样,纵向亦然
    可通过axis 参数改变级联的方向

所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。
arr = np.array([1,2,3,4,5])
a = arr.copy()  #创建副本
a[1] = 10

np.sum 和
np.max/ np.min 最大/小
np.mean() 平均值

ndarray广播机制的三条规则:缺失维度的数组将维度补充为进行运算的数组的维度。缺失的数组元素使用已有元素进行补充
    规则一：为缺失的维度补1(进行运算的两个数组之间的维度只能相差一个维度)
    规则二：缺失元素用已有值填充
    规则三：缺失维度的数组只能有一行或者一列

快速排序
    np.sort()与ndarray.sort()都可以，但有区别：
        np.sort()不改变输入
        ndarray.sort()本地处理，不占用空间，但改变输入
部分排序
    np.partition(a,k)

    有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。

        当k为正时，我们想要得到最小的k个数
        当k为负时，我们想要得到最大的k个数

 

# Pandas

# 级联 维度一样,横向级联,纵向级联,形状相符
import numpy as np
a1 = np.random.randint(0,100,size=(4,5))
a2 = np.random.randint(0,100,size=(4,5))
a3 = np.random.randint(0,100,size=(4,4))
display(a1,a2,a3)
np.concatenate((a1,a2),axis=1)  #concatenate((a1, a2, ...), axis=0竖直轴向, out=None)

# 合并三张照片  九宫格图片
import matplotlib.pyplot as plt
img_arr = plt.imread('./toy.jpg')  #读取图片
plt.imshow(img_arr)  # 查看图片
im3 = np.concatenate((img_arr,img_arr,img_arr),1) #横向
im9 = np.concatenate((im3,im3,im3),0)  #纵向 
plt.imshow(im9)
plt.imshow(img_arr[40:110,50:133,:])  #图片裁剪

a1 = np.random.randint(0,100,size=(4,5))

sum 求和

a1.sum(axis=0) #a.sum(axis=None, dtype=None, out=None, keepdims=False) 列
a1.sum(axis=1) # 行
a1.sum() #总和

排序
np.sort(a1,axis=0) #不改变输入(返回新的数组,原数组不变) axis = 1行 0列 不指定的话就是的所有的都排序
a1.sort() #本地处理,不占用空间,但改变输入 --直接修改原数组,不推荐使用 a.sort(axis=-1, kind='quicksort', order=None)#Sort an array, in-place.

s1 = Series(data=[1,2,3,4,5]) # 隐式索引 默认索引
s2 = Series(data=[1,2,3,4,5],index=['a','b','c','d','e']) #显示索引
s1[0],
s2[1],
s2['a']
s2[['a','b','c']]  #拿多个值

s3 = Series(data=np.random.randint(0,100,size=(9)),name='haha')  
　　s3    #用 numpy 创建Series  
dic = { 'english':100, 'yuwen':120 } #字典创建series
　　Series(data=dic) # 输出 类似于字典

s2.iloc[0:3] # iloc跟隐式 loc跟显示 切片
s2['aaa']=1000 #相当于添加键值对
s2.index # 显式索引
s2.tail(2) #后几个
s2.head(2) #前几个

# 去重
s = Series(data=[1,3,1,2,4,5,3,2,3,5,6,7,4,2,4,5,5])

s.unique()  # 返回值是 array     => array([1, 3, 2, 4, 5, 6, 7], dtype=int64) 横排打印,series竖排打印,包含索引

# 排空
s1 = Series(data=[1,2,3,4,5],index=['a','b','c','e','f'])
s = s1 +  s2  # 索引与之对齐的数相加  显示隐式都可以
# 数据清洗 去空值
s.isnull() # True Falses.notnull() #True False
#s[[True,False,True,True,False,True,False]] # 只保留True对应的值   s[[0,1,2,3]] 
s[s.notnull()]  #返回新的Series   s原始的数据不变

 索引与之对齐的加减乘除/运算

DataFrame 是由Series组成的 表格型数据结构 值 行索引 列索引   //一维拓展多维

import pandas as pd
from pandas import Series,DataFrame
df = DataFrame(data=np.random.randint(60,120,size=(3,4)),index=['a','b','c'],columns=['A','B','C','D'])   #numpy数据源
#(data=None, index 行=None, columns 列=None, dtype=None, copy=False)  3行4列

dic = { 
'zhangsan':[11,22,33,44],
'lisi':[0,1,2,3]
} #字典数据源
df = DataFrame(data=dic,index=['语文','数学','英语','化学'])

df['zhangsan'] #列索引取值,只能用 显示索引
df[['lisi','zhangsan']] #取多列

df.loc['语文'] #取行 index
df.iloc[0] 整数

df.values #所有元素
df.index  #行索引 index  obj
df.columns = ['张','李'] #列索引修改 obj
df.shape   #(3,3) 形状

df.loc['英语','zhangsan'] # 先取行,再取列
df.loc[['英语','化学'],'zhangsan'] # 取多个值

df.iloc[:,1] #隐式索引  左行右列

df[0:2]  #行切片 前两行
df.iloc[:,0:2] #列切片 前两列

df['lisi'] #索引拿到  列
df.loc[:,'lisi':'zhangsan'] #通过切片切出前两列

df.loc[['语文','数学']] #索引取行
df['语文':'数学'] #切片取行
df.loc['语文','zhangsan'] # 通过索引取元素

-----------------------------------------------

dic = {
'zhangsan':[11,22,33,44],
'lisi':[0,1,2,3]
}
df = DataFrame(data=dic,index=['语文','数学','英语','化学'])
df_qz = df
qimo = df_qz
qimo['zhangsan']=[88,99,100,110]
(df_qz+qimo)/2 　　　　　　　　　　 #期中期末平均成绩
df_qz.loc['数学','zhangsan']=0   #数学改0分
df_qz['lisi'] =df_qz['lisi']+100 #lisi所有成绩加100
df_qz = df_qz + 10 　　　　　　　  #所有人的各门课都加10