import pandas as pd

import numpy as np

df1 = pd.DataFrame(np.random.randn(3,4),columns=['A','B','C','D'])

df2 = pd.DataFrame(np.random.randn(2,3),columns=['A','B','D'])

print(df1)

print(df2)

print(pd.concat([df1,df2]))  #默认 axis=0

print(pd.concat([df1,df2],axis=1))#默认 join='ourter'

print(pd.concat([df1,df2],axis=1,join='inner')

#默认 join='ourter'

print(pd.concat([df1,df2],axis=0,join='inner',ignore_index=True))

#axis=0 (纵向)，join=inner（内连接交集），ignore_index=True (重新设置索引)

df1 = pd.DataFrame({'id':[1,2,3,4,5],'age':[34,28,22,29,17],'ctg':list('AABCB')})

df2 = pd.DataFrame({'id':[3,4,5,6,7],'ticket':['1001','1002','1003','1004','1005'],'amount':[24.1,32.5,34.8,19.5,26.2]})

new = pd.merge(df1,df2,how='inner',on='id')

print(new)

core = pd.read_excel(r'data\core.xlsx')

print(core)

print("以下是pearson（皮尔森)")

print(core[['E','F']].corr(method='pearson'))  #pearson（皮尔森)

print(core[['G','F']].corr(method='pearson'))  #pearson（皮尔森), 有一个列值相同

print(core[['D','F']].corr(method='pearson'))  #pearson（皮尔森)，有异常值

print("以下是spearman（斯皮尔曼)")

print(core[['E','G']].corr(method='spearman'))   #spearman（斯皮尔曼)

print(core[['D','F']].corr(method='spearman'))   #spearman（斯皮尔曼)

print("以下是kendall(肯德尔)")

print(core[['D','F']].corr(method='kendall'))  #kendall (肯德尔)

#线性插值

from scipy.interpolate import interp1d

x = pd.DataFrame({'x':[1,2,3,4,5,8,9,10]})

y1 = pd.DataFrame({'y1':[2,8,18,32,50,128,162,200]})

y2 = pd.DataFrame({'y2':[3,5,7,9,11,17,19,21]})

data = pd.concat([x,y1,y2],axis=1)

print(data)

data1 = interp1d(data['x'],data['y1'],kind='linear')

data2 = interp1d(data['x'],data['y2'],kind='linear')

print(data1([6,7]))

print(data2([6,7]))

#读取 data\core.xlsx 文件中的数据，使用 3σ 原则分析 D 列是否存在异常值。

import pandas as pd 

data = pd.read_excel(r'data\core.xlsx')

def out_range(ser1):

    bool_ind = (ser1.mean()-3*ser1.std() >ser1) |(ser1.mean() +3*ser1.std()< ser1)

    index = np.arange((ser1.shape[0]))[bool_ind]

    outrange = ser1.iloc[index]

    return outrange

print(data)

out = out_range(data['D'])

print(out)

#读取 data\core.xlsx 文件中的数据，使用箱线图分析年龄异常值。

import pandas as pd

import  matplotlib.pyplot as plt

data = pd.read_excel(r'data\core.xlsx')

plt.figure(figsize=(10,8),dpi=160)

p = plt.boxplot(list(data['年龄'].values))

outlier1 = p['fliers'][0].get_ydata()

plt.savefig(r'data/异常.jpg')

plt.show()

import pandas as pd

from sklearn.preprocessing import StandardScaler

from sklearn.preprocessing import MinMaxScaler

data = pd.DataFrame([['北京','-5','25','18'],

                     ['上海','-2','27','20'],

                     ['广州','3','33','25'],

                     ['深圳','5','35','28']],

                    columns=['地区','最低气温','最高气温','最常气温'])

#标准差（Z-score) 标准化数据

s_scaler = StandardScaler()

df = data.iloc[:,1:]

print(df)

print("标准差（Z-score)标准化数据:")

print(s_scaler.fit_transform(df))

#归一化 (离差）标准化数据

print("归一化(离差）标准化数据:")

max_min_scaler = MinMaxScaler()

print(max_min_scaler.fit_transform(df))

import pandas as pd

pay = pd.read_csv(r'data/user_pay_info.csv', index_col=0)

# 自定义离差标准化函数

def min_max_scale(data):

    data = (data - data.min()) / (data.max() - data.min())

    return data

# 对用户每月支出信息表的每月支出数据做离差标准化

pay_min_max = min_max_scale(pay['每月支出'])

print('离差标准化之前每月支出数据为：\n', pay['每月支出'].head(20))

print('离差标准化之后每月支出数据为\n', pay_min_max.head(20))

# 自定义标准差标准化函数

def standard_scaler(data):

    data = (data - data.mean()) / data.std()

    return data

# 对用户每月支出信息表的每月支出数据做标准差标准化

pay_standard = standard_scaler(pay['每月支出'])

print('标准差标准化之前每月支出数据为：\n', pay['每月支出'].head(20))

print('标准差标准化之后每月支出数据为：\n', pay_standard.head(20))

# 将特定的数据 转化为 可以使用的数据 --- 数据变换

# 两种情况：

# 第一种：哑变量转化 -- 利用 pandas 库中的 get_dummies () 函数进行哑变量处理

# 通常与 PCA（主成分分析）一起使用，即构造哑变量产生高维数据后采用 PCA 进行降维。

# pd.get_dummmies(data,prefix,prefix_sep)

# data : 需要转化的数据

# prefix: 转化之后列名称的前缀

# 1、将年龄列（非数值型）数据 -----> 数值型

data = pd.read_excel(r'data\core.xlsx')

print(data['性别'])

newagedata = pd.get_dummies(data['性别'],prefix='性别_')

# 哑变量转化为数值型数据，维度两例，可降维（删除其中一列）

newagedata = newagedata.drop(columns='性别__男')

newagedata = newagedata.rename(columns={'性别__女':'性别'})

# 2、将城市列（非数值型）数据 -----> 数值型

newcitydata = pd.get_dummies(data['城市'],prefix='城市_')

print(newcitydata)

#哑变量转化为数值型数据，维度太多，降维不好处理。

#（1）Label Encoding 给对应进行编号处理，使用 LabelEncoder () 函数将文本类型的数据转换成数字（随机）

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()

label = le.fit_transform(data['城市'])

print(label)

data['城市'] = label

print(data)

#（2）pandas 库中的 replace () 函数，按特定内容进行替换

# 先利用 value_counts () 函数查看 “城市” 列有哪些内容需要替换

print(data['城市'].value_counts())

data['城市'] = data['城市'].replace({'北京':11,'上海':12,'广州':13,'深圳':14,'佛山':15})

print(data)

all_info = pd.read_csv(r'data\user_all_info.csv')

all_info['年龄'].fillna(30)

#等宽离散化 -- 将该列中所有的年龄值按设置的等份平均划分

age_cut = pd.cut(all_info['年龄'],5)

print('等宽离散化后记录的年龄分布为:\n',age_cut.value_counts())

#等频离散化 -- 将相同数量的记录放置在每个区间

import  numpy as np

def same_rate(data,k):

    w = data.quantile(np.arange(0,1+1.0/k,1.0/k))

    data = pd.cut(data,w)

    return data

age_same_rate = same_rate(all_info['年龄'],5).value_counts()

print('等频离散化后记录的年龄分布为:\n',age_same_rate)

#聚类离散化 --- 使用 Kmeans 进行聚类，得到簇，用户指定簇的个数，用于决定生成的区间数

def kmean_cut(data,k):

    from sklearn.cluster import  KMeans

    kmodel = KMeans(n_clusters=k)  #用户指定的簇的个数调用 KMeans 算法标记数据

    kmodel.fit(data.values.reshape((len(data) ,1)))  #训练数据模型

    c = pd.DataFrame(kmodel.cluster_centers_).sort_values(0)  #输出聚类中心并排序

    w = c.rolling(2).mean().iloc[1:]  #对相邻两项求中点，作为边界点

    w = [0] + list(w[0]) + [data.max()]  #把首末边界点加上

    data = pd.cut(data, w)  #调用 cut 函数将标记后的数据离散化处理

    return  data

all_info['年龄'].dropna(inplace = True)  #将表内年龄列为空的数据删除（inplace = True 表示原表操作）

age_kmeans = kmean_cut(all_info['年龄'],5).value_counts()

print('聚类离散化后记录的年龄分布为:\n',age_kmeans)