数据清理，预处理 pandas dataframe 操作技巧 总结

dsoft2 = data1.loc[(data1['程'] == "轻") | (data1['程'] == "中")]
设置x下标
plt.xticks(np.arange(24))

特定列 排序
print(data.sort_values(axis = 0,ascending = True,by = '停留时间'))

plt.savefig(name+".jpg")

#中文
myfont = FontProperties(fname=r'C:\Windows\Fonts\simhei.ttf', size=14)
import seaborn as sns
sns.set(font=myfont.get_name())

file = open(".xlsx", "rb")
data = pd.read_excel(file, sep="\t")
data = data.loc[(data['时间'] > 0) & (data['时间'] < 4320)]
drop_feat = ["编号",..., "状态"]
feat = [i for i in data.columns if i not in drop_feat]
data = data[feat]
print(data.isnull().sum() / len(data)) #看缺失比例，字段

# 读取文档以及，过滤填充数据， 筛选数据

# ddie = data.loc[(data['等级'] == "Ⅲ") | (data['等级'] == "Ⅳ")]

data = ddie.groupby(['时段', '分类']).mean().reset_index()
dataForsize = ddie.groupby(['时段', '分类']).size().reset_index()  

dmean1 = data.loc[(data['类'] == '') | (data[''] == '')]
dsize1 = dataForsize.loc[(dataForsize['类'] == '统') | (dataForsize[''] == '')]
dmean1 = dmean1.groupby(['挂']).mean()  #  分组后 平均
dsize1 = dsize1.groupby(['挂'])[0].agg(sum)  # 计  分组后 求和

# xx = list(range(0, 24))  技巧得 x轴 连续坐标
y1 = dmean1["时间"]
x1 = y1._index._data　　技巧 对应的 索引 不连续坐标 ，  方法论：debug查 属性

plt.figure(figsize=(16,5))
plt.plot(x1, y1,color='blue')
plt.plot(x3, y3,color='red')
for i, (_x, _y) in enumerate(zip(x1, y1)):
    plt.text(_x, _y, dsize1[x1[i]], color='blue', fontsize=12) # 关键 dsize1[x1[i]]  是从连续的i找不连续的x[i]的坐标来得到不连续的y值

plt.xticks(np.arange(24))
label = [ "其它"]
plt.legend(label, loc=0, ncol=2)
plt.xlabel("  0-23小时")
plt.ylabel("时长")
plt.show()

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

==========数据集 读取 处理 合并
==========查看信息 统计>>分布
==========数据应用/建模 重要工作 看异常点，缺省值 处理字段(特征),处理脏数据 方法：查看>>获取>>处理
==========转类型，转数字 astype，Encoder，map，one-hot，pivot
==========生成相关图，分析特征图 查看数据均衡分布程度及处理：生成模拟数据：上采样，下采样 ；box-cox变换 计距离，皮尔逊

==========数据集 读取 处理 合并
data = pd.read file
data = pd.concat([a, b],ignore_index=True) Concatenate英[kɒn'kætɪneɪt DataFrame objects
data = copy.deepcopy(data[[ 'c1', 'c2']]) # data[[]] 双括号区别:多列切片
data1 = pd.concat([data1,data[""]])
data = pd.merge(data,data1,on="")

df2['col4'] = ['cnn','rnn'] # 列扩充
df2.append(pd.DataFrame({' # 行扩充
dfb.join(df_a,how='outer') # 合并DataFrame,并集

default，concat是在axis=0工作，最终产生一个‘更多列’的series，若传入axis=1结果就变成一个dataframe.

==========查看信息 统计>>分布
print(data.isnull().sum()/len(data))
print(data._info_axis) print(data.axes) axis英[ˈæksɪs]美[ˈæksɪs] 轴，轴线 axes也是轴
print(data.shape)
print(data.dtypes type(obj)) astype
print(data.head(5))
print(data.info)
print(data[''].describe())

print(dataframe.index,dataframe.columns)
图看值分布
data.boxplot(column=[''],return_type='axes')
查多少种取值(看分布)
data[].value_counts() len(data[''].unique())
print(len(data['c'].value_counts())) #len(data['c'].value_counts()) 有了count为什么还要len

排序看范围
b = pd.DataFrame(a).sort_values('').reset_index(drop=True)

==========数据应用/建模 重要工作 看异常点，缺省值 处理字段(特征),处理脏数据 方法：查看>>获取>>处理
data.apply(lambda x: sum(x.isnull()))
apply applymap

data[]和loc的区别：百度：pandas中Dataframe的查询方法（[], loc, iloc, at, iat, ix）
# 根据索引查看数据 dataframe.loc['a'] # 索引为ａ这一行的数据
data[]是 切片 一列的行做
data[[]]是 多列切片

for column in data.columns: # 重置为null , o ,
data[column] =
data[column].apply(lambda x: np.nan if x ==" "else x)
lambda x: 1 if pd.isnull(x) else 0
data[""].apply( lambda x: 0 if str(x)=="#VALUE!" else x)
data[''].apply( lambda x: 1 if pd.isnull(x) else 0)

#缺省值不多，用均值代替 keypoint
data.fillna(0,inplace=True)
data[''].fillna(0, inplace=True)
#找中位数去填补缺省值（因为缺省的不多）
data[''].fillna(data[''].median(),inplace=True)

data.dropna(inplace=True) //通常情况下删除行，使用参数axis = 0，删除列的参数axis = 1,通常不会这么做，那样会删除一个变量。 记忆 0,1,行列
data.drop(drop_feat,axis=1,inplace=True)
len(data['col'].unique())
data.drop('col',axis=1,inplace=True)

==========转类型，转数字 astype，Encoder，map，one-hot，pivot

for column in le_columns :
if column not in drop_feat:
data[[column]]=data[[column]].astype("int64")
data[[column]]=data[[column]].astype("str")

Encoder
sub_data["measures"],measures_dict = label_encode(sub_data,"measures")

def label_encode(data,column_name):
　　data[column_name] = data[column_name].astype(str)
　　data[column_name].fillna("空",inplace=True)
　　dummy_encode = pd.get_dummies(data[column_name])
　　column_num = range(len(dummy_encode.columns))
　　column_dict = {}
　　for i in column_num:
　　column_dict[dummy_encode.columns[i]] = i
　　#data[column_name] = data[column_name].apply(lambda x:column_name+"_"+x)
　　data[column_name] = data[column_name].map(column_dict)
　　return data[column_name],column_dict

数值编码
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
var_to_encode = ['Device_Type','Source']
for col in var_to_encode:
data[col] = le.fit_transform(data[col])

weekday_map = {"星期一":1,"星期二":2,"星期三":3,"星期四":4,"星期五":5,"星期六":6,"星期日":7}
season_map = {"春":1,"夏":2,"秋":3,"冬":4}
gender_map = {"男":1,"女":2}
sub_data["sex"]=sub_data["sex"].map(gender_map)
data[''] = data[''].map(lambda x: split_word(x,stopwords))

pandas使用
get_dummies 进行one-hot编码
pivot 行列转
data1 = data.pivot(index="", values="1", columns="").reset_index()

==========生成相关图，分析特征图 查看数据均衡分布程度及处理：生成模拟数据：上采样，下采样 ；box-cox变换 计距离，皮尔逊
data1 = data[["a","b"]]
corrmat = data1.corr()
plt.subplots(figsize=(12,9))
sns.heatmap(corrmat,vmax=0.2,square=True)

其它技巧
生成日期范围
pd.date_range('4/1/2012','6/1/2012')

numpy
数组转置和轴对换 区别是什么：简单的转置就是轴对换，那复杂的呢
reshape dot T transpose
有集合运算
有线代的操作函数

处理，过滤 填充 缺失数据
dropna fillan isnull notnull

逐块读取大文件，
chunker = pd.read_csv('filepath',chunkssize=100)
for a in chunker:
读几行
re = pd.read_csv('filepath',nrows=5,skiprows,na_values='',converters='映射成字典')

重塑reshape 轴向旋转pivot
stack 将数据的列转为行
unstack 将数据的行转为列
duplicated() 重复行
重命名轴索引 rename

_data["line"] = _data.apply(lambda data_row: change_str(data_row))
_detail_data["费用"] = _detail_data['门诊号'].apply(lambda x: change_patient_str(x))
前者是整行为参数，后者为单列

http://pandas.pydata.org/pandas-docs/stable/merging.html

pd.concat  连接，以索引与列引为主，比较‘直接拼接’    多用于，竖向多行合并   verify_integrity=True    左右拼接axis=1     ignore_index=True 【Clear the existing index and reset it】

pd.merge  和join  像sql 的join 左右连接多，以某个key为对应键  多用于，横向多列合并

https://blog.csdn.net/zutsoft/article/details/51498026merge  通过键拼接列

concat  可以沿着一条轴将多个对象堆叠到一起

concat方法相当于数据库中的全连接(UNION ALL),可以指定按某个轴进行连接,也可以指定连接的方式join(outer,inner 只有这两种)。

与数据库不同的时concat不会去重，要达到去重的效果可以使用drop_duplicates方法