Pandas ，Numpy笔记

Numpy

矩阵属性:

轴: (层,行,列) (0,1,2)

​ 所有数学和统计函数都有此参数 axis=0 行 axis=1列, -------思路相反-----------> np.sum(data,axis=0求每列和)

​

shape 获取维度(行,列,层)

ndim 获取维度数

size 获取元素数

dtype 元素数据类型

矩阵创建:

​ 公共参数: dtype=“type” (float/float32/ini/int32/bool)

​ 数据类型:bool/byte/short/uint/ double/ 通过dtype=np.类型

1. 将python类型转换ndarray np.array(dict/list])

2. numpy创建 1-D ndarray np.arange(start,end,step)

3. numpy创建 2-D ndarray np.eye(行,列) 行索引==列索引的元素为1，其余为0

4. 常规矩阵

   ​ 全0 np.zeros((行,列))

   ​ 全1 np.ones((行,列))

   ​ 形状相同(全1) data = np.ones_like(数组)

   ​ 形状相同(全0) data = np.zeros_like(数组)

   ​ 指定值 np.full((行,列),数值)

   ​ 形状相同+特定值 np.full_like(数组,数值)

   ​ 等差数列 np.linspace(开始,结束,个数)

   5.矩阵复制(深拷)创建 ndarray: data.copy() data[1:3].copy()

   6. 从磁盘读取矩阵 np.save(“file.npy”,data) np.load(“file.npy”)

   7. 随机生成 random

      ​ rand均匀分布([0,1],中心在值中心) randn标准正态分布(均值0,方差1，中心在0)

      ​ random.randn(n) n个随机数

      ​ random.randn(行,列) 指定行列随机数

      ​ random.randn(层,行,列) 指定层 行列随机数

      randint(x,y,size=(层,行,列)) 随机整数

      random(size=(层,行,列)) 随机生成数[0.0,1.0]

      choice(数组,size=(层,行,列)) 随机取数

      shuffle(数组) 随机排列(多维数组随机排列只按行随机，列是不变的)

      normal(平均值,方差,size=(层,行,列)) 按照平均值和方差生成高斯分布/正态分布/常态分布的数字

      uniform(x,y,size=(层,行,列)) 在[x,y) 之间生成均匀分布的数字

      保留位数(四舍五入) np.round(数值,位数)

      ​

矩阵索引:

​ data.shape 获取结构

一维

1. 单元素索引 data[index]

2. 切片 data[start:stop:step]

3. 整数数组索引 data[[1,2,3,4]] 只取索引行

4. 布尔数组索引 data[[True,False,True,True]] 只取真 (可以使用运算符)

   ​ 布尔数组: data > 2

二维

1. ​ 取行 data[index]

2. ​ 行列 data[0:2,2:3]

3. ​ 整数 data[[1,2],[0,3]]

4. ​ 布尔 data[[False,True],[True,True]]

索引数组赋值:

data[1] = 2 data[0:2]=3 data[0:2,1:3] = 4

修改形状:

​ 行列变形: data.reshape(行,列) 注意 —> 行*列 == 数组.size()

​ 展平(多维变一维): data.flatten()

​ 组合:

​ 连接 np.concatenate((data1,data2),axis=“”)

​ 水平堆叠 np.vstack(data1.data2)

​ 垂直堆叠 np.hstack(data1,data2)

​ 三维堆叠 np.dstack(data1,data2)

​

​ 垂直拆分: np.hsplit(data,拆分块数)

排序:

​

按值大小排序: np.sort(data,axis=轴,kind=‘排序算法’,order=“排序字段”)

参数	描述
axis	排序沿数组的(轴)方向,0表示按行，1表示按列，None表示展开来排序，默认值为-1，表示沿着最后的轴排序
kind	排序的算法，提供了快排(默认)‘quicksort’,混排’mergesort’,堆排’heapsort’
order	排序的字段名,可按指定字段排序，默认为None

# sort() 无参数则按最后一个轴进行排序

data = np.array([3,4,1,2,3,5,6,7,8])
data.sort() # 0轴行排序

data = np.array([[0,12,48],[4,18,14],[7,1,99]])
data.sort(data,axis=0) #0轴行排序


获取排序后下标:         数组.argsort(data,axis=轴,kind='排序算法',order="排序字段")   

根据键值的字典进行排序 : lexsort

沿轴切片:

轴: (层,行,列) (0,1,2)

​ 沿着0轴切2行 data[:2]

​ 沿着0轴切2行，沿着1轴切1列 data[:2,1:]

​

沿轴转置

​ 行列转置 data.transpose() / data.T

​ 轴转置 data.swapaxes(1,0)

​ 反转矩阵 np.flip(array,axis=“”)

深浅拷贝

浅拷贝
    a=b 不能这样赋值，因为a和b相互影响，在内存里a变了b也会发生变化
    a=b[:] 视图操作，一种切片，会创建新的对象a，但是a的数据完全由b保管，他们两个的数据变化是一致的

深拷贝
	a=b.copy() 复制，a和b互不影响，相当于是重新开辟了一个空间保存b的值，然后让a指向b.copy()

布尔

! where

data = np.array([[1,3,6],[9,3,2],[1,4,3]])
np.where(data>3,520,1314)  # 大于3为520,否则1314

data = np.array([False,False,True,False])
data.any()  # 检查数组中是否至少有一个True
data.all() # 检查是否每个值都是True

! query

矩阵计算:

1.广播

一对多的影响

四则运算时 (* / + -): data * 1 矩阵所有乘1

​ data1 + data2 形状相同，对应元素计算(行/列相同的一维可以和二维一起计算)

广播规则: 1.形状相同/形状不同，但轴长相同/ 最后一个都轴一致

​ 2.最后一个轴是1

​ （4，3） <-----可广播----> （3，） 4行3列对1行3列，有一轴长一致，即可广播

​ (2,4,3) <----可广播-----> (4,3) 行列一致，可广播

​ （2,4,3） <----可广播—> (3) 列一致，可广播

2.通用函数

一元函数 (数组) axis
abs,fabs	计算整数,浮点数或复数的绝对值,对于非复数,可以使用更快的fabs
sqrt	计算各个元素的平方根,相当于arr**0.5,要求arr每个元素必须是非负数
square	计算各个元素的评分,相当于arr**2
exp	计算各个元素的指数e的x次方
log,log10,lg2,log1p	分别计算自然对数,底数为10的log,底数为2的log,以及log(1+x)，要求arr每个元素必须正数
sign	计算各个元素的正负号:1正数，0零，-1负数
ceil	计算各个元素的ceiling值,即大于等于该值的最小整数
floor	计算各个元素的floor值,即小于等于该值的最大整数
rint	将各个元素值四舍五入到最接近的整数，保留dtype的类型
modf	将数组中元素的小数位和整数位以两部分独立数组的形式返回
isnan	返回一个表示"那些值是NaN(不是一个数字)"的布尔类型数组
isfinite,isinf	分别表示"那些元素是有穷的(非inf,非nan) “或"那些元素是无穷的布尔型数组”
cos,cosh,sin,sinh,tan,tanh	普通以及双曲线型三角函数
arccos / arccosh, arcsin / arcsinh, arctan / arctanh	反三角函数

二元函数 (数组,数组) axis
mod	元素级的求模计算(除法求余)
dot	求两个数组的点积
greater,greater_equal / less,less_equal / equal , not_equal	执行元素级别的比较运算，最终返回一个布尔型数组
logical_and, logical_or,logical_xor	执行元素级别的布尔逻辑运算,相当于(& | ^)
power	求解对数组中每个元素进行给定次数的指数值，类似于: arr**x

3.统计函数

方法 (data,axis=“”) axis=0每列计算 axis=1每行计算	描述
sum	沿着轴向，计算所有元素的累加和，0长度的数组累加和为0
average	加权平均,参数可以指定weights
prod	所有元素的乘积
mean	数学平均,0 长度的数组平均值为NaN
std,var	标准差和方差,可以自由度调整(默认分母是n)
.cov()	相关系数矩阵
min.max	最小和最大值
argmin,argmax	最小和最大值的位置
cumsum	从0开始元素累积和
cumprod	从1开始元素累积积
median	中位数
prercentile	0-100百分位数
quantile	0-1分位数
argmax(np.bincount(arr))	众数 (适用于一维，元素不能为浮点) 建议使用Pandas mode()方法

概念

1、平均数：所有数加在一起求平均

2、中位数：对于有限的数集，可以通过把所有观察值高低排序后找出正中间的一个作为中位数。如果观察值有偶数个，通常取最中间的

两个数值的平均数作为中位数

3、众数：出现次数最多的那个数

4、加权平均数：**加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。加权平均值的大小不仅取决于
    总体中各单位的数值（变量值）的大小，而且取决于各数值出现的次数（频数），由于各数值出现的次数对其在平均数中的影响起着权衡
    轻重的作用，因此叫做权数。 因为加权平均值是根据权数的不同进行的平均数的计算，所以又叫加权平均数。在日常生活中，人们常常
    把“权数”理解为事物所占的“权重”      x占a% y占b% z占c% n占m%
    加权平均数=（ax+by+cz+mn）/(x+y+z+n)





5.轴:   (层,行,列)   (0,1,2)
所有数学和统计函数都有此参数 axis=0 行   axis=1列,     -------思路相反-----------> np.sum(data,axis=0求每列和)
其中思路正好是反的：axis=0 求每列的和。axis=1求每行的和。
    行：每行对应一个样本数据
    列：每列代表样本的一个特征

数组对应到现实中的一种解释:
    对于机器学习、神经网络来说，不同列的量钢是相同的，收敛更快。
    有两个特征，一个是商品单价1元至50元，另一个是销售数量3千个至1万个，这两个数字不可比，所以需要都做标准化。
    比如在Excel里，单价一个列，销售数量一个列，不同列代表不同特征，所以用axis=0做计算
     标准化一般使用：通过均值和方差实现
    数组 = （数组 - mean(数组，axis=0)）/ std(数组, axis=0)

4.集合

方法	描述
unique(x)	计算x的唯一值（去重）,并排序
intersect1d(x,y)	计算x和y的交集，并排序
union1d(x,y)	计算x和y的并集,并排序
inid(x,y)	计算x中的元素是否包含在y中<返回一个布尔数组
setdiff1d(x,y)	差集,在x中但不在y中的x元素
setor1d(x,y)	亦或集，在x或y中,但不属于x,y交集的元素

5.去重

(展平 )获取唯一元素列表:np.unique(data)

​ 获取唯一元索引列表:np.unique(data,return_index=True)

(去重行/列) np.unique(data,axis=“”)

Pandas

读/写数据

类型	读	写
.csv/.tsc/.txt	read_csv(路径,seq=“分隔符”,header=“表头”,index_col=False,encoding=“”，skiprows=跳过行数,nrows=读取行数)	to_csv(路径,seq=“分隔符”,header=“表头”,index=False,encoding=“”)
.xlsx	read_execl(路径,sheet_name=“工作表名”,skiprows=跳过行数,nrows=读取行数)	to_execl(路径,sheet_name=“工作表名”,index=True)
.json	read_json()	to_json()
.sql	read_sql(“sql语句”,con=“连接对象”)	to_sql(表名,连接对象)

数据结构

data.dtype 查看数据结构

Series 系列 “一维数据”

系列可以保存任何数据类型,轴标签为索引(可以是ndarray,dict,标量值. 长度需与数据长度一致)

创建 data = pd.Series(d,index=index)

切片 ndarray —> data[0] data[0:1]行切片 data[[0,1,2]] 取指定行

​ dict ----> data[“key”]

常用方法
数据.index #查看索引
数据.values #查看数值
数据.isnull() #查看为空的，返回布尔型
数据.notnull() 
数据.sort_index() #按索引排序
数据.sort_values() #按数值排序

DataFrame 数据帧 “多维数据”

数据帧是一种二维数据结构，其列不同的类型(一维数组,列表,字典,series，dataframe,ndarray,结构化数据)

创建: data = pd.DataFrame(d,index=index,colums=colums)

选择: data[“colums”] / data.iloc[''colums] (series)

添加: data[‘newcolums’] = data[‘colums’]

删除: data.pop[“colums”]

切片: data[0:1] 行切片 / data.iloc[0:1,0:1] 行列切片 (dataframe)

转置: data.transpose() / data.T

常用方法
数据.head( 5 ) #查看前5行
数据.tail( 3 ) #查看后3行
数据.values #查看数值
数据shape #查看行数、列数
数据.fillna(0) #将空值填充0
数据.replace( 1, -1) #将1替换成-1
数据.isnull() #查找数据中出现的空值
数据.notnull() #非空值
数据.dropna() #删除空值
数据.unique() #查看唯一值
数据.reset_index() #修改、删除，原有索引，详见例1
数据.columns #查看数据的列名
数据.index #查看索引
数据.sort_index() #索引排序 
数据.sort_values() #值排序
pd.merge(数据1,数据1) #合并
pd.concat([数据1,数据2]) #合并
pd.pivot_table( 数据 ) #用df做数据透视表

常用操作

查看数据

1. 首尾数据 head(n) tail(n)

2. 随机抽 sample(n)

3. 数据结构 shape

4. 查看信息 info()

5. 查看列名列表 columns

6. 查看索引列 index

7. 查看数据 values

8. 数据统计摘要 describe()

9. 最值索引 idxmin() idxmax()

10. 查看数据类型 dtypes

11. 显示数据行和列名 axes

12. 显示列中不重复值 team.unique()

13. 查看列数据 data[“列名”]

选取数据

整数索引 .iloc(整数，列表，切片，布尔数组)

1. 行切片 data.iloc[0:3] (可以修改 data.iloc[0:3] = 0)
2. 行列切片 data.iloc[0:3,0:2]
3. 列选择 data.iloc[[1,2,3]] (行列选择data.iloc[[1,2,3],[0,1]])

标签索引 .loc([行索引],[列名称])

布尔索引(用于筛选数据):

​ 每个表达式必须用括号分组,运算符(| or & and ~ not > < == !=)

​ data[data[“colums”]>0]

​ data[(data[“colums”]>0) | (data[‘colums’]<100)]

筛选数据

1.数据筛选

每个表达式必须用()包裹

​ 表达式: data[data[‘colums’]>0]

​ where()方法: data[data[“colums”]>0] = data.where(data[“colums”]> 0) 支持运算符

​ query()方法 data[data[“colums”]>0] = data.query(“colums >0”) 支持运算符

2.文本筛选

startwith()	筛选开头
endwith()	筛选结尾
contains()	包含
truncate(before/after=“日期”)	筛选指定日期之前/后

类型转换

data.astype(‘python类型’) int/float/double/str

方法(data,dtype=“numpy类型”)

合并/连接/追加/删除

连接: pd.concat([data1,data2],axis=“”,index=“”,join=“”，sort=“”) 相同字段首尾相连

合并 (dataframe/series): pd.merge(data1,data2,on=“列名”,how=“合并方法”)

合并方法	描述
left	仅使用左框架中的键
right	仅使用右帧中的键
outer 全连接	使用两个帧中的键并集
inner 内连接（默认）	使用两个帧中键的交集

# 基于一个字段  pd.merge(data1,data2,on="列名",how="合并方法")

# 基于多个字段  pd.merge(data1,data2,on=["列名","列名"],how="合并方法")

# 注意可以使用  join    data1.join(data2,on="",how="")

​

追加

​ df1.append(df2, axis=“”,ignore_index=True) 相同字段首尾相连,无效字段数据为NaN

​

删除数据

​ 行 drop(labels=[行号],axios=0,)

​ 列 drop(labels=[列名],axios=1,)

去重

​ unique() 返回唯一值列表

​ 提取重复 duplicated返回一个布尔向量，其长度是行数，指示行是否重复。True为重复

​ 删除重复 drop_duplicates(subset=["列名"],keep='first/last/False')删除重复的行

排序

参数

（数据,axis="",ascending="",inplace=""）
ascending=True/False  升/降
inplace=True  直接对数据进行排序(不返回新对象) / 返回新对象

单列:  data.sort_values(by="",assending=True,inplace=True)
多列:  data.sort_values(by=["",""],assending=["",""],inplace=True)

​

按索引排序 sort_index()

按列值排序 sort_values(by=[“列”])

按索引和值排序 sort_values(by=[“索引”,“列”])

复制

copy()

转换/重塑

行列转换: data.transpose() / data.T

数据替换

1. 常规替换 data[“”] = x

2. 数值替换 data.replace(‘旧字符’,‘新字符’,inplace=True)

3. 替换指定的某个或多个数值

   data.replace({‘列元素’:‘’,‘列元素’:‘’},inplace=True)

   data.replace([‘‘列元素,‘列元素’],[’’,‘’],inplace=True)

4. 替换某个数据部分内容 data[“列”] = data[“列”].str.replace(“”,“”)

5. 字符串操作

data.str
.replace(“”,“”)	字符替换
.astype(‘type’)	类型转换
.cat(data2,sep=‘分隔符’)	字符拼接
.split(‘’,n=-1全部/指定次数)	字符切割
.partition(‘字符’)	字符切割一次
.get(index)	获取指定位置字符(只取一个)
.slice(开始,结束，步长)	获取指定范围的字 (字符串切片)
.slice_replace(开始,结束,替换字符串)	切片后替换
.join(‘字符’)	字符联结
.contains(‘字符’)	判断字符串是否包含指定字符(返回布尔)
.startswith(‘字符’)	是否某个字符开头
.endswith(‘字符’)	是否某个字符结尾
.repeat(重复次数)	重复字符串
.pad(占位长度,fillchar=‘字符’,side=“right/left/both”)	将每个元素额外填充一个字符
.zfill(占位数量)	每个元素额外填充 ‘0’ (从左边)
.encode(‘’)	字符编码
.decode(‘’)	字符解码
.strip()	去除两边指定字符
.translate({‘旧字符’:‘新字符’})	指定部分替换
.find(‘字符’)	查找指定字符第一次出现的位置
.lowewr()	所有字符小写
.upper()	所有字符大写
.title()	第一个单词首字母大写
.capitalize()	首字母大写
.swapcase()	大小写转换
.isalpha()	判断是否全字母
.isnumeric()	判断是否全数字
.isalnum()	判断是否全字母或数字
.isspace()	判断是否全空格
.islower()	判断是否全小写
.istitle()	判断每个单词的首字母是否大写(其他字母小写)
.match()	正则模式匹配
.extract()	分组捕获

数据统计

参数(series,axis=轴)

数据统计摘要 describe()

count(data[‘’].unique())	去重元素数量
count / len	非空值数量
sum	求和
mean	求平均值
mad	平均绝对方差
median	中位数
min	最小值
max	最大值
mode	众数
abs	绝对值
prod	乘积,连乘
std	标准差
var	方差
sem	均值的标准误差
skew	样本偏度（第 3 矩） 偏度系数
kurt	样本峰度（第4矩）
quantile	样本分位数（以 % 为单位的值）
cumsum	累计连加再加
cumprod	累计连乘再乘
cummax	累计最大值
cummin	累积最小值
argmin	最小值索引位置(整数)
argmax	最大值索引位置(整数)
idxmin	每列最小值索引
idxmax	每列最大值索引
cov()	协方差
corr()	相关系数
rank()	排名
pct_change()	时间序列变化
nunique()	去重数量，不同值的量

滚动窗口计算

rolling(距离).窗口函数()

窗口函数
count()	非空个数
sum()	求和
mean()	求平均
max() / min()	最大最小
rank()	排名
median()	中位数
var()	方差
std()	标准差

缺失值处理

查看缺失值

​ 是缺失(返回布尔数组) data.isnull()

​ 不是缺失(返回布尔数组) data.notnull()

删除缺失值

​ data.dropna(axis=“”,how=‘’,thresh=None,subset=[],inplace=False)

​ axios设置删除包含缺失值的轴

​ how(与axis配合使用): any只要缺失值出现就删除该行该列 all所有的值都缺失，才删除行或列

​ thresh: axis中至少有个thresh个非缺失值，否则删除

​ subset: 在哪些列中查看

填充缺失值

(0/平均值/中值/其他)

​ data.fillna(value=“填充值”,method=None,axis=None) 可以直接写fillna(填充值)

method 填充方式	若变轴，则左右就是前后
ffill	用前面的值填充
bfill	用后面的值填充
pad	向后填充
backfill	向前填充
limit 限制填充数量

​

（分组聚合）拆分/应用/合并

拆分成组: data.groupby(“分组字段”,axis=“”)

按组排序: data.groupby(“分组字段”,axis=“”,sort=False).统计函数()

组内应用多个函数: data.groupby(“分组字段”,axis=“”).agg([“函数名”,“函数名”])

将不同的函数应用于不同列: data.groupby(“分组字段”,axis=“”).agg({“列名”:“函数名”，“列名”:“函数名”})

按组过滤: data.groupby(“分组字段”,axis=“”).filter(自定义函数)

按组应用(高级函数): data.groupby(“分组字段”,axis=“”).apply(自定义函数)

多列单方法: data.groupby([‘分组字段’,‘分组字段’])[‘聚合字段’].sum()

多列多方法: data.groupby(([‘分组字段’,‘分组字段’])).agg({‘聚合字段’:聚合方法,‘聚合字段’:聚合方法})

agg函数基于列聚合 ： data.agg(fun,axis=“”,参数)

groupby基于行聚合

数据对齐

对没对齐的数据进行补空填充，来对齐数据

数据运算

1.算数运算(±*/)

data[‘x’].fillna(0) + data[‘y’].fillna(0)

​ 空值与数字进行计算结果为空值,

​ 1/0=inf 无穷大 -1/0负无穷大 0/0=Nan

2.灵活运算

data[‘x’].add(data[y],fill_value=0)

方法	反转方法	描述
add	radd	加法
sub	rsub	减法
div	rdiv	除法
floordiv	rfloordiv	整除
mul	rmul	乘法
pow	rpow	幂次方

3.高阶函数

1. 表函数应用： pipe（）
2. 按行或按列的函数应用程序：apply（）
3. 聚合 API：agg（） 和 transform（）
4. 应用 Elementwise Functions： applymap（）

对数据进行逐行，逐列，逐元素的操作

map(): 把数据逐个传入字典或函数中(参数少)

# 对指定列元素进行替换
1.data['列'] = data['列'].map({'原元素':'新元素'})


def fun(x):
	if x =='原元素':
		return '新元素'
2.data['列'] = data['列'].map(fun)

apply(): 与map功能一致，但是(参数多)

def fun(x,args): //第一个是默认逐个传入的参数   第二个是args传入的参数
	if x =='原元素':
		return '新元素' + args
		
2.data['列'] = data['列'].apply(fun,args=(1,)，axis="")
     axis=0 对每列   1对每行

applymap()： 对每个单元格进行函数操作

数据透视

直观的显示要分组聚合统计的数据结果

矩阵 data.pivot(index=“索引列”,colums=“行”,values=“透视列”)

表 pd.pivot_table(data,index=[“索引列”],columns=[“行”],values=[“透视列”],aggfunc=[np.统计函数])