项目学习

• 读取数据

# 对于单个字段的数据类型不一致处理方法：
#         1.dtype={}:指定列的类型(更推荐)
#         2.low_memory = False: 使pandas一次性读取csv中所有数据(pandas读取csv文件默认是按块读取的，即不一次性全部读取，pandas在读取不同块时对同一字段的数据类型猜测结果不一致)

train = pd.read_csv('round1_diac2019_train.csv',dtype={'customer_province':str,'customer_city':str})
col_names = train.columns.tolist()


# drop_duplicate():是对DataFrame格式的数据,去除特定列下面的重复行;返回DataFrame格式的数据
# dropna():滤除缺失数据

all_customer = pd.DataFrame(trian[['customer_id']]).drop_duplicates(['customer_id']).dropna()

• 数据标准化 归一化

标准化（normalization）：将数据按比例缩放，使之落入一个小的特定区间
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
X = ss.fit_transform(X)
origin_data = ss.inverse_transform(X)

归一化：标准化的一种，将数据统一映射到[0,1]区间上
from sklearn.preprocessing import MinMaxScaler
mm = MinMaxScaler()
X = mm.fit_transform(X)
origin_data = minmaxScaler.fit_transform(X)    # 还原

• 时间数据处理

import datetime

# 转化为时间格式
train['order_pay_time'] = pd.to_datetime(train['order_pay_time'], format="%m/%d/%y %H:%M:%S")

# 提取日期(年-月-日)
train['order_pay_date'] = train['order_pay_time'].dt.date

# datetime.timedelta(days / seconds / microseconds):代表两个时间之间的时间差;两个date或datetime对象相减就可以返回一个timedelta对象
validata_date_begin = train['order_pay_date'].max() - datetime.timedelta(days=180)

# 时间的比较(可转化为字符串进行)
train_history = train[train['order_pay_time'].astype(str) < '2013-07-04']

• 数据映射

province_mapping = {'四川省':1 , '安徽省':2 , '福建省':3 , '河北省':4 ,
 '贵州省':5,'山东省':6,'黑龙江省':7, '广东省':8,'北京':9,'重庆':10,'浙江省':11,
 '辽宁省':12,'河南省':13,'海南省':14,'湖南省':15,'甘肃省':16,'陕西省':17,
 '内蒙古自治区':18,'江苏省':19,'天津':20,'上海':21,'云南省':22,'湖北省':23,'江西省':24,'吉林省':25,'山西省':26,
 '宁夏回族自治区':27,'西藏自治区':28,'新疆维吾尔自治区':29,'广西壮族自治区':30,'青海省':31,'柔佛':32,
 '香港特别行政区':33,'台湾':34,'NaN':0}
trian['customer_province_num'] = trian['customer_province'].map(province_mapping)

• 数据分割

from sklearn.model_selection import train_test_split

# train_test_split(train_data,train_target,test_size=0.3, random_state=0):用于将矩阵随机划分为训练子集和测试子集，并返回划分好的训练集测试集样本和训练集测试集标签
#    train_data：被划分的样本特征集
#    train_target：被划分的样本标签
#    test_size：如果是浮点数，在0-1之间，表示样本占比；如果是整数的话就是样本的数量
#    random_state：是随机数的种子；其实就是一个划分标记，对于同一个数据集，如果rondom_state相同，则划分结果也相同
#    shuffle：是否打乱数据的顺序，再划分，默认True
#    stratify：none或者array/series类型的数据，表示按这列进行分层采样

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=42,stratify=y)

• pandas：function()

1.groupby():基于行的聚合操作	
	对数据集进行切片、切块、摘要等操作
	返回值：返回重构格式的DataFrame(groupby里面的字段内的数据重构后都会变成索引)
  agg():基于列的聚合操作

df = pd.DataFrame({'A': ['a', 'b', 'a', 'c', 'a', 'c', 'b', 'c'],
                   'B': [2, 7, 1, 3, 3, 2, 4, 8],
                   'C': [100, 87, 96, 130, 105, 87, 96, 155]})
output:
	   A  B    C
	0  a  2  100
	1  b  7   87
	2  a  1   96
	3  c  3  130
	4  a  3  105
	5  c  2   87
	6  b  4   96
	7  c  8  155  
	
df.groupby('A').apply(np.mean)	      # 不同列使用同一种方法
output:
	          B           C
	A                      
	a  2.000000  100.333333
	b  5.500000   91.500000
	c  4.333333  124.000000    

data.agg({'B':'mean','C':'sum'})       # 不同列使用不同的方法
output:
	          B    C
	A               
	a  2.000000  301
	b  5.500000  183
	c  4.333333  372         

# as_index=False：不使用其作为新的索引
df.groupby(['A'], as_index=False)['B'].agg({'count':'count'})
output:
	   A  count
	0  a      3
	1  b      2
	2  c      3

2. merge()

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
	left_index=False, right_index=False, sort=True)

left - 一个DataFrame对象
right - 另一个DataFrame对象
on - 列(名称)连接，必须在左和右DataFrame对象中存在(找到)
left_on - 左侧DataFrame中的列用作键，可以是列名或长度等于DataFrame长度的数组
right_on - 来自右的DataFrame的列作为键，可以是列名或长度等于DataFrame长度的数组
left_index - 如果为True，则使用左侧DataFrame中的索引(行标签)作为其连接键。 在具有MultiIndex(分层)的DataFrame的情况下，级别的数量必须与来自右DataFrame的连接键的数量相匹配
right_index - 与右DataFrame的left_index具有相同的用法
how - 它是left, right, outer以及inner之中的一个，默认为内inner。 
sort - 按照字典顺序通过连接键对结果DataFrame进行排序。默认为True，设置为False时，在很多情况下大大提高性能。
copy 设置为False，可以在某些特殊情况下避免将数据复制到结果数据结构中

data = pd.merge(customer_id,good_price,on=['customer_id'],how='left',copy=False)