数据分析与展示Pandas库复习

常用方法

官网：

MOOC Python数据分析与展示

pandas官网

基础概念

引用：import pandas as pd
Pandas基于NumPy实现，常与NumPy和Matplotlib一同使用

与numpy区别

Numpy关注数据结构表达

Pandas库数据类型

Series

Series类型由一组数据及其相关索引组成

import pandas as pd
d = pd.Series(range(3))
#0 0
#1 1
#2 2

import pandas as pd
#可省略index
d = pd.Series([9,8,7],index=['a','b','c'])

创建Series类型

从
列表

s=pd.Series([1,2,3])#此时不能省略index

标量值

s=pd.Series(25,index=['a'])#此时不能省略index

Python字典

s=pd.Series({a:9,'b':8})

…

基本操作

类型包括index,value

操作类似ndarray,python字典类型

b = pd.Series([9,8,7],index=['a','b','c'])

b.index
#Index(['a','b','c'],dtype='object')
b.value
#Index(['9','8','7'],dtype='int64')
b['b'] #8
b[:1] # a 9

b[b>b.dedian]#大于中位数

#查找是否存在
'c' in b
#True
b.get('f',100)

series类型在运算中会自动对齐不同索引的数据
Series对象和索引都可以有一个名字，存储在属性name中

b.name=''
b.index.name='index'

Series对象可以随时修改并即刻生效

运算操作
。。。
特征类操作
。。。
关联操作
。。。

DataFrame

一个表格型的数据类型，每列值类型可以不同

DataFrame既有行索引、也有列索引

创建方法

• 二维ndarray对象

d = pd.DataFrame(np.arange(10).reshape(2,5))

• 由一维ndarray、列表、字典、元组或Series构成的字典

dt = {'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3],index=['a','b','c'])}`
d = pd.DataFrame(dt,index=['b','c','d'],colums=['two','three'])

dt = {'one':[1,2,3],'two':[1,2,3]}
d = pd.DataFrame(dt,index=['b','c','d'])

• Series类型
• 其他的DataFrame类型

修改Series,DataFrame

重新索引 reindex

d = d.reindex(index=['c5','c4'])
d = d.reindex(column=['城市','同比'])

Series和DataFrame的索引是Index类型，Index对象是不可修改类型

索引常用方法

• append(idx) 连接另一个Index对象，产生新的Index对象

• diff(idx) 计算差集，产生新的Index对象

• intersection(idx) 计算交集

• union(idx) 计算并集

• delete(loc) 删除loc位置处的元素

• insert(loc,e) 在loc位置增加一个元素e

• drop a.drop([‘b’,‘c’])

算术运算根据行列索引，补齐后运算，运算默认产生浮点

补齐时缺项填充NaN (空值)
二维和一维、一维和零维间为广播运算

a>c#默认在1轴

比较运算只能比较相同索引的元素，不进行补齐

loc使用例子,计算机器学习的评价函数

#preds_prob是二分类返回的概率ndarray类似[[0.1,0.9],[0.2,0.8],...], label是标签[1,0,...]
preds = [0 if row[0] > 0.5 else 1 for row in preds_prob]
pd_data = pd.concat([pd.DataFrame(preds, columns=['预测值']), pd.DataFrame(label, columns=['真实值'])], axis=1)
# 计算总体的召回率 精准度 f1值
# loc index,Single label,List of labels.
total_TP = len(pd_data.loc[(pd_data.真实值 == 1) & (pd_data.预测值 == 1)])  # 真正例
total_TN = len(pd_data.loc[(pd_data.真实值 == 0) & (pd_data.预测值 == 0)])  # 真反例
total_FN = len(pd_data.loc[(pd_data.真实值 == 1) & (pd_data.预测值 == 0)])  # 假反例
total_FP = len(pd_data.loc[(pd_data.真实值 == 0) & (pd_data.预测值 == 1)])  # 假正例

常用方法

一列转两列

（）+（）拆分

data_type = df[col].str.split('+', expand=True).stack().reset_index(level = 1,drop = True)
df = data_type.to_frame(name='通用名称')
 

计算列中元素连续出现次数

参考:https://www.zhihu.com/question/41265794

缺失值、无限值处理

any()是或操作，任意一个元素为True，输出为True
all()是与操作，所有元素为True，输出为True

检查数据集，若

np.isinf(X).any()=False

np.isfinite(X).all()=True

np.isnan(X).any()=False

则说明数据集不包含缺失值和无穷值
参考：https://blog.csdn.net/slibra_L/article/details/107928803

缺失值、无限值处理：
data.replace([np.inf, -np.inf], np.nan).dropna(axis=0)

找出所有含有空值的行

DataFrame[DataFrame.isnull().T.any()]

缺失值填充

data.dropna(how = 'all')    # 传入这个参数后将只丢弃全为缺失值的那些行
data.dropna(axis = 1)       # 丢弃有缺失值的列（一般不会这么做，这样会删掉一个特征）
data.dropna(axis=1,how="all")   # 丢弃全为缺失值的那些列
data.dropna(axis=0,subset = ["Age", "Sex"])   # 丢弃‘Age’和‘Sex’这两列中有缺失值的行   

参考：https://blog.csdn.net/qq_35843543/article/details/106471278

按照时间段生成时间列表

pd.date_range(start, end, freq) 生成一个时间段

pd.date_range('20171011', '20171030',freq='5D') 
DatetimeIndex(['2017-10-11', '2017-10-16', '2017-10-21', '2017-10-26'], dtype='datetime64[ns]', freq='5D')

pd.date_range(日期字符串, periods=5, freq=‘T’) 生成一个时间段

tm_rng = pd.date_range('20171231 12:50',periods=5,freq='M') 
 
print(type(tm_rng)) 
DatetimeIndex(['2017-12-31 12:50:00', '2018-01-31 12:50:00','2018-02-28 12:50:00', '2018-03-31 12:50:00',

去除二级索引

gp2.columns = gp1.columns.droplevel(0)

重复

参考：https://blog.csdn.net/m0_37235489/article/details/84584520

frame[frame.duplicated('pop')]

判断dataframe数据整行是否重复

flag = df.duplicated()

判断dataframe数据多列数据是否重复(多列组合查)

df.duplicated(subset = ['price','cnt'])

参数subset

subset用来指定特定的列，默认所有列

参数keep

keep可以为first和last，表示是选择最前一项还是最后一项保留，默认first

参数inplace

inplace是直接在原来数据上修改还是保留一个副本，默认为False

追加写入

name.to_csv(PATH+'.csv',mode='a',index=False,header=False)

read_sql,to_sql

df = pd.read_sql(sql,con, parse_dates='') #解析日期列
from pymysql import *
conn = connect(host='',port='',database='',user='',password='')

设置dataframe显示长度

warnings.filterwarnings("ignore")
# 设置显示
# 1.显示所有列
pd.set_option('display.max_columns', None)
# 2.显示1000列
# pd.set_option('max_columns',100)
# 3.显示所有行
pd.set_option('display.max_rows', 80)
# 4.显示1000行
# pd.set_option('max_row',50)
# 5.设置value的显示长度为100，默认为50
pd.set_option('max_colwidth', 100)
#dataframe int类型不使用科学计数法
pd.set_option('display.float_format', lambda x: '%.2f' % x)

独热编码

pd.get_dummies(walmartstoredf.Store, prefix='Store').iloc[:,1:]

更改列名

df1.rename(columns={'a':'A','b':'B'},inplace=True) 

group by

聚合函数：https://www.cnblogs.com/harden13/p/13693850.html
汇总运算

# 每组大小
group_sizes = (data.groupby('species').size())
print(group_sizes)
#
data.groupby(by=['goods_id','order_day']).mean()['original_price'] 
 # 选中的多个列，每列都应用不同的多个聚合函数
df.groupby('name').agg({'chinese': [sum, 'mean'], 'math': [np.min, np.max]})

# 匿名函数实现
df.groupby('name').agg(lambda x: x.max() - x.min())

data.sum(axis = 1)      # 每列的总和
data.mean() #每行均值  

# 禁止分组键
df.groupby(['name','test'], as_index=False).sum()
# 删除，删除分组带来的外层索引
df.groupby('name').apply(top, n=2, p='math')
df.groupby('name', as_index=False).apply(top, n=2, p='math')
df.groupby('name', group_keys=False).apply(top, n=2, p='math')

merge

data = data.merge(new_data,on=['goods_id','order_day'],how='left')
 # 修改列名字
 data.rename(columns={'original_price_y':'original_price'},inplace=True) 
 data.drop(['original_price_x' ], axis=1, inplace=True) 

数据统计方法

print(data.quantile(0)) #分位数

print(data.describe())

sample = (data.sample(n=5,replace=False,random_state=42)) #采样

pd.DataFrame(y_pred).value_counts(normalize=True)#计算不同值比例

将DataFrame指定两列转成字典

df[["a", "b"]].set_index("a").to_dict()["b"]

作图

# 散点图
import matplotlib.pyplot as plt
plt.plot(data.sepal_length,data.sepal_width,ls ='', marker='o')

plt.plot(data.sepal_length, data.sepal_width, ls ='', marker='o',label='sepal')
plt.plot(data.petal_length, data.petal_width, ls ='', marker='o', label='petal')

%pylab
pyplot.scatter(X[:, 0], X[:, 1], c=y)
pyplot.show()

import seaborn as sns
sns.jointplot(x='sepal_length',y='sepal_width',data=data, size=4)

# 直方图
plt.hist(data.sepal_length, bins=25)

fig, ax = plt.subplots()
ax.barh(np.arange(10),
data.sepal_width.iloc[:10])
# Set position of ticks and tick labels
ax.set_yticks(np.arange(0.4,10.4,1.0))
ax.set_yticklabels(np.arange(1,11))
ax.set(xlabel='xlabel', ylabel='ylabel',
title='Title')

# pair
import seaborn as sns
sns.pairplot(data, hue='species', size=3)

日期处理

日期时间列中提取月份和年份

df['Year'] = df['Joined date'].dt.year 
df['Month'] = df['Joined date'].dt.month 
dt['yymmdd'].dt.strftime("%Y-%m")

# 两个日期相差天数+1
#字符串转日期，用pd.to_datetime可以统一将time.strftime("%Y/%m/%d")生成的日期转换成日期格式的数据
data[''] = pd.to_datetime(data["date"]) 
data[''] = ((data['end_day'] - data['start_day']) + datetime.timedelta(days=1)).dt.days

 # 比较大小可以用字符串直接比
 print (datetime.datetime.now()+datetime.timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S")
 # 计算同列日期差值天数
 day_span_array = ((data['日期'].values[1:] - data['日期'].
                          values[:-1]) / np.timedelta64(1, 'D')).fillna(0).astype(int)

# 当前时间+1天
import datetime
from dateutil.relativedelta import relativedelta
d = datetime.datetime.strptime('20210131', '%Y%m%d')
print(d)
print((d - relativedelta(years=1)).strftime('%Y%m%d')) 
#算两个日期date的天数差
date1 = dt.datetime.strptime(d1, "%Y-%m-%d").date()  ##datetime.date(2018, 1, 6)
date2 = dt.datetime.strptime(d2, "%Y-%m-%d").date()  ##datetime.date(2018, 1, 9)
Days = (date2 - date1).days 

计算一段时间内的工作日（除周末）

date_range(start_day, end_day,freq='b')
# date_range 默认的freq是'd'就是日期的意思，如果不带参数计算出来就是所有的天数，所有如果要用date_range计算工作日，必须要带freq='b'的参数，其他开始日期和结束日期的格式跟bdate_range一样。

节假日计算
参考：https://blog.csdn.net/Strive_0902/article/details/104976852

start_day = '2020-05-01'
end_day = '2020-05-09'
import pandas as pd
from pandas.tseries.offsets import CustomBusinessDay
def count_businessday(start_day,end_day):
    b = CustomBusinessDay(holidays=['2020-04-06','2020-05-01','2020-05-04','2020-05-05','2020-06-25','2020-10-01',
                                    '2020-10-05','2020-10-06','2020-10-07','2020-10-08'])
    bus_day = pd.date_range(start=start_day, end=end_day, freq=b)
    length = len(bus_day)
 
    extra_work_day = ['2020-04-26','2020-05-09','2020-06-28','2020-09-27','2020-10-10']
    extra_len = 0
    for i in extra_work_day:
        if i>=start_day and i<=end_day:
            extra_len = extra_len+1
 
    print(length+extra_len)
 
if __name__=='__main__':
    count_businessday(start_day,end_day)

将DataFrame中True/False 全部替换成1/0

df['cols1']=df['cols1'].astype('int')

迭代dataframe

for index, row in df.iterrows():
	...

列重命名

data.rename(columns={'商品id': 'goods_id'}, inplace=True)#列重命名

重置索引

通常用于concat后

df_total = df_total.reset_index(drop=True)

loc index操作

loc函数使用详解,跟iloc区别在于可以用索引名

可以接受label,单个多个切片

df.loc['viper'] # 行label

df.loc[['cobra','viper']] # 多个行label

df.loc['cobra', 'shield']#同时选定行和列

df.loc['cobra':'viper', 'max_speed'] #同时选定多个行 和 单个列

df.loc[[True,False,True]] # boolean选择行label

df.loc[df['shield'] > 6] # 条件布尔值
df.loc[df['shield'] > 6, ['max_speed']]

df.loc[lambda df: df['shield'] == 8] #通过函数得到布尔结果选定数据

空值检测

 data[''].isnull().values_count()
data.isnull().sum()

根据条件筛选删除空值

dropna(axis=0, how=‘any’, thresh=None, subset=None, inplace=False)
参考：python-pandas的dropna()方法-丢弃含空值的行、列

df.dropna() #删除为na的行

# 根据条件删除
df.drop(df[df[].str.len()>50].index)
data.drop(data[data['']==].index.tolist())
sample_data = sample_data[sample_data.生产厂家.str.contains('三九') == True]#

 
df.dropna(subset=['列名'],inplace=True) #删除某列有空值的行

字符串去除空格

data[col_name] = data[col_name].str.strip()

排序

参考：pandas | DataFrame中的排序与汇总方法

dataframe
有根据值排序以及根据索引排序这两个功能

df.sort_values(by=["",""] , inplace=True, ascending=True) #列排序

df.sort_index(axis=1)#索引排序

series

obj.sort_values()
obj.sort_index()

排名

obj.rank(method = first)#同个值不取平均

去重

df = df.drop_duplicates()
df = df.drop_duplicates([''])#根据某列去重

赋值

df.loc[['viper', 'sidewinder'], ['shield']] = 50 #根据选定列行赋值

df.loc['cobra'] =10# 将某行row的数据全部赋值

# 多条件赋值
df.loc[(df['price']>0)&(df['price']<100),'列名']=10#df.loc[][]错误

# 某列数据赋值
df.loc[:, 'max_speed'] = 30
df['rq'] = df['rq'].max()


#条件选定rows赋值
df.loc[df['shield'] > 35] = 0


# 先创建空列（这是第一种创建新列的方法）
df['wencha_type'] = ""
df.loc[df["bWendu"]-df["yWendu"] > 10,"wencha_type"] = "温差大"
df.loc[df["bWendu"]-df["yWendu"] <=10,"wencha_type"] = "温差正常" 

筛选

筛选行

df.loc[7:9] #行索引是数值
df[ df["colname"] > value ]
df[ df["col1"] > val1 & df["col2"] != val2] 

df[df[''].isin([])]#要用.isin 而不能用in,用 in以后选出来的值都是True 和False

mask = df.apply(lambda row: row["col"].val < 100, axis=1)
df[mask]

筛选列

df = [[col1,col2,col3,col4]]   #注意要用双括号
dt.loc[:,'':'']

多维索引
获取某个colum的某row的数据，需要左边传入多维索引的tuple，然后再传入column

df.loc[('cobra', 'mark i'), 'shield']

df.loc['cobra'] #传入的就是最外层的row label，返回DataFrame

#传入的是索引元组，返回Series
df.loc[('cobra', 'mark ii')]
df.loc['cobra', 'mark i']


#获取某个colum的某row的数据，需要左边传入多维索引的tuple，然后再传入column
df.loc[('cobra', 'mark i'), 'shield']

分箱

参考：python pandas 分箱操作

#等宽分箱
pd.cut(df[''],bins = 3)

# 指定宽度分箱
pd.cut(df[''],#分箱数据
 bins = [0,60,90,120,150],#分箱断点
 right = False,# 左闭右开
 labels=['不及格','中等','良好','优秀'])# 分箱后分类
 
pd.qcut(df[''],q=4,labels=[1,2,3,4]) #等频率分箱

转换数据类型

df[''] = df[''].astype(int)

新增列

DataFrame 新增列的五种方法

data.insert(data.shape[1], 'd', 0)

data['d'] = 0 #直接对 DataFrame 直接赋值即可

data.loc[index, col] = value

抽样

import pandas
#随机从数据集中抽取200行数据，并且保证下次抽取时与此次抽取结果一样
df.sample(n=200,random_state=123,axis=0)
 
#随机从数据集中抽取50%的行数据
df.sample(frac=0.5,axis=0)

apply操作

参考：https://blog.csdn.net/rankiy/article/details/102938678

def not_null_count(column):
    column_null=pd.isnull(column)
    null=column[column_null]
    return len(null)
    
#调用函数计算空值
count=data.apply(not_null_count)

#创建分类函数
def class_column(column):
    c_class=column[4]
    if pd.isnull(c_class):
        return 'null'
    elif c_class <=-0.5:
        return '[-1,-0.5]'
 #调用函数分类数据
data[5]=data.apply(class_column,axis=1)

 

append操作

参考：
Pandas知识点-添加操作append
pandas的DataFrame的append方法详细介绍

import pandas as pd
# 添加字典
data = pd.DataFrame()
a = {"x":1,"y":2}
data = data.append(a,ignore_index=True)
print(data)

# 添加series
series = pd.Series({"x":1,"y":2},name="a")
data = data.append(series)
print(data)

Excel

read_excel(),to_excel()

创建空dataframe

df = pd.DataFrame(columns = ["a", "b", "c", "d"]) #创建一个空的dataframe
df = pd.DataFrame(index= ["1", "2", "3", "4"]) #创建一个空的dataframe

list转pandas

pd.concat([pd, pd.DataFrame(list,columns=['point'])],axis=1)