Cacher is the code snippet organizer for pro developers

#numpy.array
#构造 
a = numpy.array([1,2,3,4])
a = np.arange(5)  #array([0, 1, 2, 3, 4])
a = np.ones((2,3), dtype=int) 
a = np.zeros((rows,cols),dtype=int)
b = np.random.random((3,2)) #返回随机浮点数位于半开区间 [0.0, 1.0)
b = np.random.randint(low,high,(rows,cols))  #返回随机整数位于半开区间 [low, high)
b = np.random.randn(rows,cols)  #返回标准正态分布样本
b = np.round(np.random.normal(mu,sigma,N),2)
http://blog.csdn.net/unin88/article/details/50570196

#转换 
a = numpy.array([1,2,3,4])
b = a.astype(np.float32)
a.tolist()

#连接 
np.append(x,y)  #x,y可为数，list或numpy.array类型
#concatenate()效率更高
a=np.array([1,2,3])
b=np.array([11,22,33])
np.concatenate((a,b),axis=0)  # 默认情况下，axis=0可以不写
array([ 1,  2,  3, 11, 22, 33])

a=np.array([[1,2,3],[4,5,6]])
b=np.array([[11,21,31],[7,8,9]])
np.concatenate((a,b),axis=0)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [11, 21, 31],
       [ 7,  8,  9]])

np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
array([[ 1,  2,  3, 11, 21, 31],
       [ 4,  5,  6,  7,  8,  9]])

y = a**2  #元素平方
y.shape 
y[y>5]  
numpy.dot(a,b)  #矩阵乘法 
numpy.column_stack((a,b))

y.min(),y.max(),y.sum(),y.sort()
numpy.mean(z[0,:])  #均值 
numpy.median(z[0,:])  #中位数
np.percentile(z,95)
numpy.corrcoef(x,y)
numpy.std(x)

Numpy 基本数据
inti	整数，大小由平台决定
int8	整数，大小为一个字节，范围：-128 ~ 127
int16	整数，范围：-32768 ~ 32767 
int32	整数，范围：-2**31 ~ 2*31-1 
int64	整数，范围：-2**63 ~ 2*63-1 
uint8	无符号整数，0 ~ 255
uint16	无符号整数：0 ~ 65535
uint32	无符号整数： 0 ~ 2**32-1
uint64	无符号整数： 0 ~ 2**64-1
float16	 半精度浮点数： 16位 ，正负号1位，指数5位，精度10位
float32	 单精度浮点数：32位，正负号1位，指数8位，精度32位
float64 / float	双精度浮点数： 64位，正负号1位，指数11位，精度52位

random.seed(10)
random.seed()           #省略参数，意味着取当前系统时间

# 随机浮点数
random.random()

# 返回指定范围的一个随机整数，包含上下限
random.randint(a,b)

# 返回[x, y)内的随机实数
random.uniform(x,y)

# 按步长随机在上下限范围内取一个随机数
random.randrange(start,stop,step)

# 随机的选取一个字符
random.choice('abcde./;[fgja13ds2d')

# 随机的选取n个字符
random.sample('abcdefghijk',3)

# 列表洗牌
random.shuffle(list)

import pandas as pd, numpy as np
#打印版本 
pd.__version__ 

#导入、出csv文件
csv_chunks = pd.read_csv('order_products__prior.csv',chunksize = 10000)
prior_orders = pd.concat(chunk for chunk in csv_chunks)

orders = pd.read_csv('../input/orders.csv', engine='c', dtype={'order_id': np.int32, 
                                                           'user_id': np.int32, 
                                                           'eval_set': 'category',
                                                           'order_number': np.int32, 
                                                           'order_dow': np.int8, 
                                                           'order_hour_of_day': np.int8, 
                                                           'days_since_prior_order': np.float16})
print('orders {}: {}'.format(orders.shape, ', '.join(orders.columns)))
orders.to_csv('csvfilename') #可选参数：encoding='utf-8', index=False（不含索引）
#nrows=1000(读前1000行)，usecols=[1,3,5]（读135列），usecols=['A','B','C']（读ABC列）

#分块读取大文件
reader = pd.read_table('tmp.sv', sep='|', chunksize=4)
for chunk in reader:
    print(chunk)
#或
reader = pd.read_table('tmp.sv', sep='|', iterator=True)
print reader.get_chunk(5)

#DataFrame
print('Total orders: {}'.format(orders.shape[0])) #行数 
print(orders.info())  #字段与占用内存 
print(order_details.dtypes) #字段类型 
df['Category'].unique()
print('Memory consumption: {:.2f} Mb'.format(sum(order_details.memory_usage(index=True,deep=True) / 2**20)))
orders.head() 
df.isnull().any() #判断是否有数据缺失
np.where(df.isnull())   #查找缺失值坐标
df[df.isnull().values==True]  #显示有缺失值的行
df.describe()

# 查看特征分布
df.boxplot(column='Fare', by = 'Pclass') #箱线图
plt.hist(df['Fare'], bins = 10, range =(df['Fare'].min(),df['Fare'].max()))
#如果变量是categorical的，想看distribution，则可以：
df.PdDistrict.value_counts().plot(kind='bar', figsize=(8,10))
# 透视表
pd.pivot_table(df, index='FaultClass', columns='UseDays', margins=True) #margins设置为True可以得到分项总计数据
pd.crosstab(df.FaultClass,df.UseDays, margins=True)


# 格式变换
format = lambda x: '%.2f' % x
frame.applymap(format)
frame['e'].map(format)

#DataFrame每一列是Series 类型，转换为numpy的ndarray: array(df.columns[0])
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
df['E'] = np.where(df['D'] >= 0, '>=0', '<0')
df['F'] = np.random.randint(0, 2, 6)
df = pd.DataFrame({ 'A': ['A0', 'A1', 'A2', 'A3'],  
                     'B': ['B0', 'B1', 'B2', 'B3'],  
                     'C': ['C0', 'C1', 'C2', 'C3'],  
                     'D': ['D0', 'D1', 'D2', 'D3']}) 

#处理异常值 
df = df[df.X.isnull().values==False]
df.fillna({'column1':'0', 'column2':'1'})
sub = df['X'].quantile(0.999)
df.loc[df['X']>sub,'X'] = sub

# 值替换
subdict = {'柴油滤芯':'柴滤', '空气滤芯':'空滤', '机油滤芯':'机滤', '机、滤':'机滤', '更换液压油':'液压油', '起动电机':'起动机'}
df_clean.MaterialName.replace(subdict, inplace=True)
df_clean['MaterialName'] = df_clean['MaterialName'].map(subdict)

loc，基于列label，可选取特定行（根据行index）
iloc，基于行/列的position
ix，为loc与iloc的混合体，既支持label也支持position

df.loc[:,('one','two')] #返回Series 
df.loc[:,df.columns[:2]]
df.iloc[:,:2] #返回Series 
df.ix[:,('one','two')]  #返回DataFrame
df.ix[:,:2]

# 删除行
df = df.drop([rowid1, rowid2])
df.drop(df.index[[rowid1, rowid2]],inplace=True)

# 去重
df.drop_duplicates(['k2'])

#筛选 
df[(df.C>0)&(df.D<0)][['A','B']]
df[df[C].isin([1,3,4,5])]
#排序 
df.sort_values(['A','D'],ascending=False)

# 增加列
df['newCol'] = None
pd.concat([df, pd.DataFrame(columns=list('DE'))])
df.reindex(columns=list('ABCDE'), fill_value=0)
#删除列 
orders.drop(['order_number'], axis=1, inplace=True)
#列改名 
op_train.rename(columns={'reordered': 'label'}, inplace=True)
#改变列的顺序 
b = df.pop('b')
df.insert(0, 'b', b)

#两个df相merge
#两个df的column都一样, index不重复(增加行)，列的顺序不影响:
pd.concat([df1,df2])  #result = result.reset_index(drop=True)
#concat([df1,df2]) 等价于 df1.append(df2)
#两个df的index一样, column不同(增加列)
pd.concat([df1,df2], axis = 1)
#concat([df1,df2],axis=1) 等价于 merge(df1,df2,left_index=True,right_index=True,how='outer')，列数是两表并集

#左连接，products表有商品的department_id，需补充具体department
pd.merge(left=products, right=departments, how='left')  
#how指的是左右两个表主键那一列中存在不重合的行时，取结果的方式：inner表示交集，outer 表示并集，left 和right 表示取某一边。

df.apply(func, axis=0,...)  #对象是DataFrame
df['one'].map(sqrt)  #对象是Series 

pd.value_counts(df["E"])  #计数
pd.pivot_table(df,index=['E','F']) #分组汇总
pd.pivot_table(df,index=['E','F'], aggfunc=[np.sum, np.mean])
df.pivot_table(index=['E','F'], aggfunc=[np.sum, np.mean])

df.groupby(['E','F']).mean()
df.groupby(['E','F']).agg(['sum', 'mean'])
df.groupby(['E','F']).agg({'A':['mean','sum'], 'B':'min'})

#分组汇总
df = pd.DataFrame(((random.randint(2012, 2016), random.choice(['tech', 'art', 'office']), \
'%dk-%dk'%(random.randint(2,10), random.randint(10, 20)), '') \
for _ in xrange(10000)), columns=['publish_time', 'classf', 'salary', 'title'])

df.groupby(['publish_time', 'classf', 'salary'])\
.count()['title'].groupby(level=0, group_keys=False).nlargest(10)

#pandas的Index对象具有字典的映射功能
col_index.get_loc('pop')
col_index.get_indexer(['pop','year'])

#MultiIndex多重索引 
user_product_time.columns
#MultiIndex(levels=[[u'order_dow', u'order_hour_of_day'], [u'mean', u'std']],
#           labels=[[0, 0, 1, 1], [0, 1, 0, 1]])
#取内层索引所有'std'列 
user_product_time.loc[:,(slice(None),'std')]

#series转ndarray
foo = ser.as_matrix()
#DataFrame转ndarray
foo = df.as_matrix()
foo = df.values
foo = np.array(df)

#dataframe按行迭代
from numpy.random import randn
df = pd.DataFrame({'a': randn(100000), 'b': randn(100000)})
from itertools import izip
for r in izip(df.index, df['a'], df['b']):
    test_list.append((r[0], r[1], r[2]))

for r in zip(df.index, df['a'], df['b']):
    test_list.append((r[0], r[1], r[2]))
    
for ir in df.itertuples():
    test_list.append((ir[0], ir[1], ir[2]))  

for i, r in enumerate(df.values):
    test_list.append((df.index[i], r[0], r[1]))

# following are too slow
# for i,r in df.iterrows():
#     test_list.append((df.index[i], r['a'], r['b']))
# for r in xrange(len(df)):
#     test_list.append((df.index[r], df.iloc[r,0], df.iloc[r,1]))

# 观察数据分布
import plotly
import plotly.figure_factory as ff
# 为根据生还区分类别 ， 字符化survived   1生还，0死亡
data['Survived'] = data['Survived'].astype('str')
fig = ff.create_scatterplotmatrix(data, diag='histogram',index='Survived',colormap=[ '#32CD32', '#00F5FF'],
                                  height=800, width=800)
plotly.offline.plot(fig, filename='p2.html')

#nan的赋值
x = float("nan")
x = numpy.nan

#nan的判断
import math
math.isnan(x)

def isNaN(num):
    return num != num
    
#在dataframe中查找nan
df[df.isnull().values==True]

#第一种方法：
df['value'] = df.groupby('category')['value'].apply(lambda x: x.fillna(x.mean()))

#第二种方法：
df['value'] = df['value'].fillna(df.groupby('category')['value'].transform('mean'))

#第三种方法：
cols = [col for col in df.columns if col not in['indstry']]
# 分组的列
gp_col = 'indstry'
# 查询nan的列
df_na = df[cols].isna()
# 根据分组计算平均值
df_mean = df.groupby(gp_col)[cols].mean()
# 依次处理每一列
for col in cols:
    na_series = df_na[col]
    names = list(df.loc[na_series,gp_col])     
    t = df_mean.loc[names,col]
    t.index = df.loc[na_series,col].index
    # 相同的index进行赋值     
    df.loc[na_series,col] = t
print(df)