""" test 1 简单画图"""
# from matplotlib import pyplot as plt
#
# fig = plt.figure(figsize=(20, 8), dpi=80)  # figure图形图标的意思，这里是指我们画的图，figsize表示图像大小，dpi表示图片清晰度
# x = range(2, 26, 2)  # 数据在x轴的位置，是一个可迭代对象
#
# y = [15, 13, 14.5, 17, 20, 25, 26, 26, 27, 22, 18, 15]  # 数据在y轴的位置，是一个可迭代对象
# plt.plot(x, y)  # 传入x和y，通过plot绘制出折线图
#
# plt.xticks(x) # 设置x轴的刻度
# # plt.xticks(x[::2]) # 当刻度太密集的时候使用列表步长来解决，matplotlib自动帮我们对应
#
# # plt.savefig(\'./pic.png\')  # 保存图片
# plt.show()  # 在执行程序的是否展示图形

""" test 2 自定义x轴标签，中文乱码解决，添加图例等"""
# # 使用 fc-list :lang=zh 查看中文字体
# # 指定字体的路径，然后在使用的时候使用fontproperties指定字体
#
# from matplotlib import pyplot as plt
# from matplotlib import font_manager
# import random
#
# my_font = font_manager.FontProperties(fname=\'/home/felix/.local/share/fonts/SIMHEI.TTF\')  # 字体的路径
#
# plt.figure(figsize=(20, 8), dpi=80)
# x = range(120)
#
# random.seed(10)  # 设置随机种子，让不同时候随机得到的结果都相同
# y = [random.uniform(20, 35) for i in range(120)]  # 随机产生数据
# y2 = [random.uniform(20, 35) for i in range(120)]  # 随机产生数据
#
# plt.plot(x, y, label=\'10点到12点天气变化\')  # 如果要添加图例则使用label指定图例名称
# plt.plot(x, y2, label=\'13点到14点天气变化\')
# plt.legend(prop=my_font, loc=\'best\')  # 图例通过prop指定字体，通过loc指定位置
#
# _x_ticks = [\'10点{}分\'.format(i) if i < 60 else \'11点{}分\'.format(i - 60) for i in x]  # 产生自定义的x轴数组
#
# # 将第一个参数的x的位置用第二个参数的数组一一对应显示，rotation表示旋转，fontproperties表示指定字体
# plt.xticks(x[::5], _x_ticks[::5], rotation=90, fontproperties=my_font)
# # 添加描述信息
# plt.xlabel(\'时间\', fontproperties=my_font)  # 设置x轴的标签
# plt.ylabel(\'温度(℃)\', fontproperties=my_font)  # 设置y轴的标签
# plt.title(\'10点到12点每分钟的时间变化情况\', fontproperties=my_font)  # 设置title
#
# plt.grid(alpha=0.4,linestyle=\':\') # 绘制网格
# plt.show()

""" 常用统计图对比 """
# 折线图:以折线的上升或下降来表示统计数量的增减变化的统计图
# 特点:能够显示数据的变化趋势，反映事物的变化情况。(变化)
#
# 直方图:由一系列高度不等的纵向条纹或线段表示数据分布的情况。
# 一般用横轴表示数据范围，纵轴表示分布情况。
# 特点:绘制连续性的数据,展示一组或者多组数据的分布状况(统计)
#
# 条形图:排列在工作表的列或行中的数据可以绘制到条形图中。
# 特点:绘制连离散的数据,能够一眼看出各个数据的大小,比较数据之间的差别。(统计)
#
# 散点图:用两组数据构成多个坐标点，考察坐标点的分布,判断两变量
# 之间是否存在某种关联或总结坐标点的分布模式。
# 特点:判断变量之间是否存在数量关联趋势,展示离群点(分布规律)

""" test 3 散点图 """

# import random
# from matplotlib import (
#     pyplot as plt,
#     font_manager,
# )
#
# # 设置字体
# my_font = font_manager.FontProperties(fname=\'/home/felix/.local/share/fonts/SIMHEI.TTF\')
#
# y_3 = [random.randint(8, 15) for i in range(31)]
# y_10 = [random.randint(10, 25) for j in range(31)]
#
# x_3 = range(1, 32)
# x_10 = range(51, 82)
#
# # 设置图形大小
# plt.figure(figsize=(20, 8), dpi=80)
#
# # 使用scatter绘制散点图
# plt.scatter(x_3, y_3, label="3月份")
# plt.scatter(x_10, y_10, label=\'10月份\')
#
# # 调整x轴的刻度
# _x = list(x_3) + list(x_10)
# _xtick_labels = [\'3月{}日\'.format(i) for i in x_3]
# _xtick_labels += [\'10月{}日\'.format(i - 50) for i in x_10]
#
# plt.xticks(_x[::3], _xtick_labels[::3], fontproperties=my_font, rotation=45)
#
# # 添加图例
# plt.legend(prop=my_font, loc=\'upper left\')
#
# # 添加描述信息
# plt.xlabel(\'时间\', fontproperties=my_font)
# plt.ylabel(\'温度 单位(t)\', fontproperties=my_font)
# plt.title(\'3月份和10月份的温度变化散点图\', fontproperties=my_font)
#
# plt.show()


""" test 4 条形图1 """

# import random
# from matplotlib import (
#     pyplot as plt,
#     font_manager,
# )
#
# # 设置字体
# my_font = font_manager.FontProperties(fname=\'/home/felix/.local/share/fonts/SIMHEI.TTF\')
#
# a = [\'电影{}\'.format(i) for i in range(30)]  # 电影名称
# b = [random.randint(10, 50) for i in range(30)]  # 电影票房
#
# # 设置图形大小
# plt.figure(figsize=(20, 8), dpi=80)
# # 绘制条形图
# plt.bar(range(len(a)), b, width=0.3)
# # 设置字符串到x轴
# plt.xticks(range(len(a)), a, fontproperties=my_font, rotation=45)  # x轴对应
# plt.savefig(\'电影统计.png\')
# plt.show()

""" test 5 条形图2 """

# 绘制横着的条形图
# import random
# from matplotlib import (
#     pyplot as plt,
#     font_manager,
# )
#
# # 设置字体
# my_font = font_manager.FontProperties(fname=\'/home/felix/.local/share/fonts/SIMHEI.TTF\')
#
# a = [\'电影{}\'.format(i) for i in range(30)]  # 电影名称
# b = [random.randint(10, 50) for i in range(30)]  # 电影票房
#
# # 设置图形大小
# plt.figure(figsize=(8, 20), dpi=80)
# # 绘制横着的条形图
# plt.barh(range(len(a)), b, height=0.3, color=\'orange\')
# # 设置字符串到x轴
# plt.yticks(range(len(a)), a, fontproperties=my_font)  # x轴对应
# # 添加网格
# plt.grid(alpha=0.3)
#
# plt.savefig(\'电影统计.png\')
# plt.show()

""" test 6 条形图3 """
# from matplotlib import (
#     pyplot as plt,
#     font_manager,
# )
#
# # 设置字体
# my_font = font_manager.FontProperties(fname=\'/home/felix/.local/share/fonts/SIMHEI.TTF\')
#
# a = [\'猩球崛起\', \'敦刻尔克\', \'蜘蛛侠\', \'战狼2\']
# b_16 = [15746, 312, 4497, 319]
# b_15 = [12357, 156, 2045, 168]
# b_14 = [2358, 399, 2357, 362]
#
# bar_width = 0.1
# x_14 = list(range(len(a)))
# x_15 = [i + bar_width for i in x_14]
# x_16 = [i + bar_width for i in x_15]
#
# plt.figure(dpi=80)
#
# plt.barh(x_14, b_14, color=\'red\', height=bar_width, label=\'9月14日\')
# plt.barh(x_15, b_15, color=\'yellow\', height=bar_width, label=\'9月15日\')
# plt.barh(x_16, b_16, color=\'blue\', height=bar_width, label=\'9月16日\')
#
# plt.yticks(x_15, a, fontproperties=my_font)
# plt.legend(prop=my_font)  # 标签
# plt.show()

""" test 7 直方图1 """

# import random
# from matplotlib import (
#     pyplot as plt,
#     font_manager,
# )
#
# # 一般来说能够使用直方图的都是那些没有统计过的数据
#
# # 设置字体
# my_font = font_manager.FontProperties(fname=\'/home/felix/.local/share/fonts/SIMHEI.TTF\')
#
# a = [random.randint(10, 100) for i in range(100)]
# # 直方图组数计算方式：将数据分组，当数据在100个以内时，按数据多少常分5-12组
# # 组距：指每个小组的两个端点的距离
# # 组数：极差/组距
# d = 5  # 组距
# num_bins = (max(a) - min(a)) // d  # 注意组距一定要被numbins整除，否则会不均匀
# print(num_bins)
#
# plt.hist(a, num_bins)
#
# # 设置x轴的刻度
# plt.xticks(range(min(a), max(a) + d, d))
# # 显示网格
# plt.grid()
# plt.show()


""" test 8 直方图2 """
# import random
# from matplotlib import (
#     pyplot as plt,
#     font_manager,
# )
#
# # 直方图应用场景
# # 1、用户的年龄分布状态
# # 2、一段时间内用户的点击次数的分布状态
# # 3、用户活跃时间分布状态
#
# # 绘制不同刻度的x轴的直方图
#
# interval = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 60, 90]
# width = [5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 30, 60]
# quantity = [random.randint(500, 9000) for i in range(len(interval))]
#
# plt.figure(figsize=(20, 8), dpi=80)
#
# plt.bar(range(len(quantity)), quantity, width=1)
#
# # 设置x轴的刻度
# _x = [i - 0.5 for i in range(len(quantity) + 1)]
# _xtick_labels = interval + [150]
# plt.xticks(_x, _xtick_labels)
# plt.grid()
#
# plt.show()
#

# -*- coding: utf-8 -*-
# @Time    : 18-12-26 下午7:01
# @Author  : Felix Wang

""" test1 numpy入门和简单使用"""
#
# # numpy简介
# # 一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组上执行数值运算
#
# import numpy as np
#
# # 创建数组
# # 下面的a，b，c效果相同
# a = np.array([1, 2, 3, 4, 5])
# b = np.array(range(1, 6))
# c = np.arange(1, 6)  # arange用法： arange([start,] stop[,step,],dtype=None)
#
# # 数组的类名：
# a = np.array([1, 2, 3, 4, 5, 6])
# print(type(a))  # <class \'numpy.ndarray\'>
# print(a.dtype)  # int64
#
# # 指定创建的数组的数据类型
# a = np.array([1, 0, 1, 0], dtype=np.bool)
# print(a)  # [ True False  True False]
#
# # 修改数组的数据类型
# a = a.astype(np.int8)
# print(a)  # [1 0 1 0]
#
# # 修改浮点型的小数位数
# b = np.round(a, 2)  # 将浮点数保留两位
# print(b)
#
# print(\'#\' * 15)
#
# c = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
# print(c)
#
# # 查看数组的形状
# print(c.shape)  # (2, 6)
# d = c.reshape(3, 4)
# # [[3 4 5 6]
# #  [7 8 4 5]
# #  [6 7 8 9]]
# print(d)
# print(d.shape)  # (3, 4)
#
# # 把数组转化为1维数组
# e = d.flatten()
# print(e)  # [3 4 5 6 7 8 4 5 6 7 8 9]
# # 注意 下面这个不是转换为一维数组
# ee = d.reshape(1, 12)
# print(ee)  # [[3 4 5 6 7 8 4 5 6 7 8 9]]
#
# # 加减乘除法
# # 注意：加减乘除在运算过程中，值被作用到所有的元素上
# print(\'#\' * 15)
# print(d)
# # [[3 4 5 6]
# #  [7 8 4 5]
# #  [6 7 8 9]]
# print(d + 1)
# # [[ 4  5  6  7]
# #  [ 8  9  5  6]
# #  [ 7  8  9 10]]
# print(d * 2)
# # [[ 6  8 10 12]
# #  [14 16  8 10]
# #  [12 14 16 18]]
# print(\'#\' * 15)
#
# #######################################
# a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
# b = np.array([[21, 22, 23, 24, 25, 26], [27, 28, 29, 30, 31, 32]])
# # 数组和数组的加减法,对应的各个值相加减，或者相乘除
# print(a + b)
# # [[24 26 28 30 32 34]
# #  [31 33 35 37 39 41]]
# print(a * b)
# # [[ 63  88 115 144 175 208]
# #  [108 140 174 210 248 288]]
#
# # c = a.reshape(3, 4)  # 注意不同的维度的不能相乘除
# # print(a * c)
# # 但是：
# # 2行6列的数组,和1行6列的数组
# a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
# c = np.array([1, 2, 3, 4, 5, 6])
# print(a-c)
# # [[2 2 2 2 2 2]
# #  [3 3 3 3 3 3]]
# print(a*c)
# # [[ 3  8 15 24 35 48]
# #  [ 4 10 18 28 40 54]]
#
# # 2行6列的数组,和2行一列的数组
# a = np.array([[3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9]])
# c=np.array([[1],[2]])
# print(c+a)
# # [[ 4  5  6  7  8  9]
# #  [ 6  7  8  9 10 11]]
# print(c*a)
# # [[ 3  4  5  6  7  8]
# #  [ 8 10 12 14 16 18]]
# # 造成上面这种不同维度能计算的原因是：
# # 如果两个数组的后缘长度，即从末尾开始算起的维度的轴长度相符或其中一方的长度为1，则认为他们是广播兼容的。广播会在缺失和长度为1的维度上进行
#

""" test2 numpy读取文件 """

# import numpy as np
#
# # numpy读取数据方法
# # np.loadtxt(fname,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)
# # frame: 文件、字符串或产生器，可以是.gz或bz2压缩文件
# # dtype： 数据类型，可选，CSV的字符串以什么数据类型读入数组中，默认np.float
# # delimiter: 分隔字符串，默认是任何空格，改为逗号
# # skiprows： 跳过前x行，一般跳过第一行表头
# # usecols： 读取指定的列，索引，元组类型
# # unpack： 如果为True，读入属性将分为写入不同数组变量，False读入数据只写入一个数组变量，默认False
#
#
# us_file_path = "US_video_data_numbers.csv"
# uk_file_path = "GB_video_data_numbers.csv"
#
# # t1 = np.loadtxt(us_file_path,delimiter=",",dtype="int",unpack=True)
# t2 = np.loadtxt(us_file_path, delimiter=",", dtype="int")
#
# # print(t1)
# print(t2)
#
# print("*" * 100)
#
# # 取行
# # print(t2[2])
#
# # 取连续的多行
# # print(t2[2:])
#
# # 取不连续的多行
# # print(t2[[2,8,10]])
#
# # print(t2[1,:])
# # print(t2[2:,:])
# # print(t2[[2,10,3],:])
#
# # 取列
# # print(t2[:,0])
#
# # 取连续的多列
# # print(t2[:,2:])
#
# # 取不连续的多列
# # print(t2[:,[0,2]])
#
# # 去行和列，取第3行，第四列的值
# # a = t2[2,3]
# # print(a)
# # print(type(a))
#
# # 取多行和多列，取第3行到第五行，第2列到第4列的结果
# # 去的是行和列交叉点的位置
# b = t2[2:5, 1:4]
# # print(b)
#
# # 取多个不相邻的点
# # 选出来的结果是（0，0） （2，1） （2，3）
# c = t2[[0, 2, 2], [0, 1, 3]]
# print(c)


""" test3 numpy中的其他操作"""
# import numpy as np
#
# # 求转置的三种方法
# b = np.array([[1, 2, 3, 4, 5, 6], [4, 5, 6, 7, 8, 9]])
# print(b)
# print(b.T)
# print(b.swapaxes(1, 0))
# print(b.transpose())
#
# # numpy中的三目运算符
# c = np.where(b < 5, 10, 0)  # 如果b中的数字小于5，则至10，否则置0
# print(c)
#
# # 小于x替换为x，大于y替换为y
# bb = np.array(
#     [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, np.nan, np.nan, np.nan]])
# print(bb)
# cc = bb.clip(10, 18)
# print(cc)

""" test4 numpy中的nan和inf """
# # nan： 表示不是一个数字
# #     当我们读取本地文件为float的时候，如果有缺失，就会出现nan
# #     或者做了一个不合适的计算的时候。
#
# # inf：表示正无穷，-inf表示负无穷
# #     比如：一个数字除以0（python中直接会报错，numpy中是一个inf或者-inf）
# import numpy as np
#
# a = np.nan
# b = np.inf
# print(a, type(a))  # nan <class \'float\'>
# print(b, type(b))  # inf <class \'float\'>
#
# # numpy中的nan的注意点
# # 1、两个nan是不相等的
# # 2、np.nan!=np.nan
# # 3、利用2的特性判断数组中nan的个数 # np.count_nonzero(t!=t)
# # 4、使用np.isnan(a)来判断一个数组中是否是nan，比如希望把nan替换为0，t[np.isnan(t)]=0
# # 5、nan和任何值计算都为nan
#
# # 在一组数据中如果单纯的把nan替换为0，是不合适的，比如全部替换为0后，替换之前的平均值如果大于0，替换之后的均值肯定会变小，所以更一般的方式是把缺失的数字替换为均值(中值)
# # 或者是直接删除有缺失值的一行
# """ 将nan替换为均值的方法
# def fill_ndarray(t1):
#     for i in range(t1.shape[1]):  # 遍历每一列
#         temp_col = t1[:, i]  # 当前的一列
#         nan_num = np.count_nonzero(temp_col != temp_col)
#         if nan_num != 0:  # 不为0，说明当前这一列中有nan
#             temp_not_nan_col = temp_col[temp_col == temp_col]  # 当前一列不为nan的array
#
#             # 选中当前为nan的位置，把值赋值为不为nan的均值
#             temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean()
#     return t1
#
#
# if __name__ == \'__main__\':
#     t1 = np.arange(24).reshape((4, 6)).astype("float")
#     t1[1, 2:] = np.nan
#     print(t1)
#     t1 = fill_ndarray(t1)
#     print(t1)
# """
#
# # numpy中常用统计函数
# # 求和：t.sum(axis=None)
# # 均值：t.mean(a,axis=None)  受离群点的影响较大
# # 中值：np.median(t,axis=None)
# # 最大值：t.max(axis=None)
# # 最小值：t.min(axis=None)
# # 极值：np.ptp(t,axis=None) 即最大值和最小值之差
# # 标准差：t.std(axis=None)
#
#
# # 数组的拼接，注意：竖直拼接的时候，每一列代表的意义要相同，否则牛头不对马嘴
# t1 = np.array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]])
# t2 = np.array([[12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]])
# tt1 = np.vstack((t1, t2))  # 竖直拼接
# tt2 = np.hstack((t1, t2))
# print(tt1)
# # [[ 0  1  2  3  4  5]
# #  [ 6  7  8  9 10 11]
# #  [12 13 14 15 16 17]
# #  [18 19 20 21 22 23]]
# print(tt2)
# # [[ 0  1  2  3  4  5 12 13 14 15 16 17]
# #  [ 6  7  8  9 10 11 18 19 20 21 22 23]]
#
# # 数组的行列交换
# print(tt1)
# tt1[[1, 2], :] = tt1[[2, 1], :]  # 行交换
# print(tt1)
# tt1[:, [0, 2]] = tt1[:, [2, 0]]  # 列交换
# print(tt1)


""" test5 更多其他方法 """
# import numpy as np
#
# # 1、获得最大值最小值的位置
# #     # np.argmax(t,axis=0)
# #     # np.argmin(t,axis=1)
# # 2、创建全为0的数组： np.zeros((3,4))
# # 3、创建全为1的数组： np.ones((3,4))
# # 4、创建一个对角线为1的正方形数组(方阵)：np.eye(3)
#
# # numpy生成随机数
# # print(np.random.rand(4,2,3)) # 创建均匀分布的的随机数数组，浮点数，范围：0-1
# # print(np.random.rand(1,2))
#
# print(np.random.randn(2, 2))  # 创建标准正态分布随机数，浮点数，平均数0，标准差1
#
# print(np.random.randint(1, 10, (3, 4)))  # 从给定上下限范围选取随机整数,最后一个参数为形状
#
# print(np.random.uniform(1, 10, (3, 4)))  # 产生具有均匀分布的数组，第一个参数为起始值，第二个参数为结束值，第三个参数为形状
#
# print(np.random.normal(1, 1, (3, 4)))  # 从指定正态分布中随机抽取样本，分布中心是第一个参数（均值），标准差为第二个值，第三个参数为形状
#
# print(np.random.seed(10))  # 随机数中值，可以通过设置相同的种子，使没吃生成的随机数相同

# -*- coding: utf-8 -*-
# @Time    : 18-12-27 下午2:51
# @Author  : Felix Wang

""" test1 pandas简单操作 """
# # pandas 常用数据
# # 1、 Series 一维，带标签数组
# # 2、 DataFrame 二维，Series容器
#
# import numpy as np
# import pandas as pd
# import string
#
# # 创建Series方式一：
# t = pd.Series(np.arange(10), index=list(string.ascii_uppercase[:10]))
# print(t)
# print(type(t)) # <class \'pandas.core.series.Series\'>
#
# # 创建Series方式二
# a = {string.ascii_uppercase[i]:i for i in range(10)}
# b = pd.Series(a)
# print(a)
# print(b)
# c = pd.Series(a,index=list(string.ascii_uppercase[5:15]))
# # 注意：重新给其指定其他的索引之后，如果能够对应上，就取其值，如果不能就为nan，因为nan为float类型，pandas会自动改变dtype
# print(c)
#
# # pandas的索引和切片
# print(c[2:10:2])
# print(c[1])
# print(c[c>4])
#
# print(b[\'A\'])
# print(b[[2,3,6]])
#
# # Series的索引和值
# print(b.index)
# print(b.values)
# # 注：Series对象的本质上是由两个数组构成
# # 一个数组构成对象的键(index,索引)，一个数组构成对象的值(values)。键->值。

""" test2 pandas读取数据 """
# import pandas as pd
#
# #pandas读取csv中的文件
# df = pd.read_csv("./dogNames2.csv")
# df2 = pd.read_sql()
# df3 = pd.read_excel()
# df4 = pd.read_json()

""" test3 DataFrame对象 """
# import string
# import pandas as pd
# import numpy as np
#
# t = pd.DataFrame(np.arange(12).reshape((3, 4)))
# #    0  1   2   3
# # 0  0  1   2   3
# # 1  4  5   6   7
# # 2  8  9  10  11
# print(t)
#
# # DataFrame对象既有行索引，又有列索引
# # 行索引，表明不同行，横向索引，叫index，0轴，axis=0
# # 列索引，表名不同列，纵向索引，叫columns，1轴，axis=1
#
# t2 = pd.DataFrame(np.arange(12).reshape((3, 4)), index=list(string.ascii_uppercase[:3]),
#                   columns=list(string.ascii_uppercase[-4:]))
# #    W  X   Y   Z
# # A  0  1   2   3
# # B  4  5   6   7
# # C  8  9  10  11
# print(t2)
#
# # DataFrame的基础属性
# # df.shape # 行数，列数
# # df.dtypes # 列数据类型
# # df.ndim  # 数据维度
# # df.index # 行索引
# # df.columns # 列索引
# # df.values # 对象值，二维ndarray数组
#
# # # DataFrame整体情况查询
# # df.head(3) # 显示头部几行，默认5行
# # df.tail(3) # 显示末尾几行，默认5行
# # df.info() # 相关信息概览：行数，列数，列索引，列非空值个数，列类型，内存占用
# # df.describe() # 快速综合统计结果：计数，均值，标准差，最大值，四分位数，最小值
#
# # 排序
# ## 按值排序
# # df.sort_values(by, axis=0, ascending=True, inplace=False, kind=\'quicksort\', na_position=\'last\')
# # #### 参数说明
# # axis:{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照索引排序，即纵向排序，如果为1，则是横向排序
# # by:str or list of str；如果axis=0，那么by="列名"；如果axis=1，那么by="行名"；
# # ascending:布尔型，True则升序，可以是[True,False]，即第一字段升序，第二个降序
# # inplace:布尔型，是否用排序后的数据框替换现有的数据框
# # kind:排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心
# # na_position : {‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面
#
#
# # # pandas 之loc和iloc
# # # 1、df.loc 通过标签索引行数据
# # # 2、df.iloc 通过位置获取行数据
# # print(\'*\' * 30)
# # print(t2)
# #
# # print(t2.loc[\'A\', \'W\'])  # 0
# # print(t2.loc[[\'A\', \'C\'], [\'W\', \'Z\']])  # 选择间隔的多行多列
# # print(t2.loc[\'A\':\'C\', [\'W\', \'Z\']])  # 冒号是闭合的可以渠道冒号后面的值
# #
# # print(t2.iloc[1, 2])  # 6
# # print(t2.iloc[1:3, 0:3])
# #
# # # 赋值更改数据
# # print(\'*\'*50)
# # print(t2)
# # t2.loc[\'A\',\'W\']=100
# # print(t2)
# # t2.iloc[1:2,0:3]=0
# # print(t2)
# #
# # # pandas的布尔索引
# # print(t2[t2[\'W\']==0])
#
#
# # pandas之字符串方法归纳
# # cat ： 实现元素级的字符串连接操作，可指定分隔符
# # contains ： 返回表示各字符串是否含有指定模式的布尔型数组
# # count ： 模式的出现次数
# # endswith,startswith ： 相当于对各个元素执行x.endswith()或x.startswith()
# # findall ： 计算各字符串的模式列表
# # get ： 获取个元素的第i个字符
# # join ： 根据指定的分隔符将Series中各元素的字符串连接起来
# # len ： 计算各字符串的长度
# # lower,upper ： 转换大小写，相当于对各个元素执行x.lower或者x.upper
# # match ： 根据指定的正则表达式对各个元素执行re.match
# # pad : 在字符串的左边、右边或者左右两边添加空白
# # center ： 相当于pad(side=\'both\')
# # repeat : 重复值。例如，s.str.repeat(3)相当于各个字符串执行x*3
# # replace ： 用指定字符串替换找到的模式
# # slice ： 对Series中的各个字符串进行子串截取
# # split ： 根据分隔符或者正则表达式对字符串进行拆分
# # strip,lstrip,rstrip ： 去除空白，包括换行符
#
# # 缺失数据的处理
# # 1、判断数据是否为NaN： pd.isnull(df),pd.notnull(df)
# # 2、处理方式
# # (1)、删除NaN所在的行列  t.dropna(axis=0,how=\'any\',inplace=False)
# # (2)、填充数据，t.fillna(t.mean()),t.fillna(t.median()),t.fillna(0)
#
# # 数据合并之join
# t3 = pd.DataFrame(np.arange(12).reshape((3, 4)), index=list(string.ascii_uppercase[:3]),
#                   columns=list(string.ascii_uppercase[-4:]))
# t4 = pd.DataFrame(np.arange(12).reshape((2, 6)), index=list(string.ascii_uppercase[:2]),
#                   columns=list(string.ascii_uppercase[-10:-4]))
#
# print(t3)
# print(t4)
# print(t3.join(t4))
# #    W  X   Y   Z    Q    R    S    T     U     V
# # A  0  1   2   3  0.0  1.0  2.0  3.0   4.0   5.0
# # B  4  5   6   7  6.0  7.0  8.0  9.0  10.0  11.0
# # C  8  9  10  11  NaN  NaN  NaN  NaN   NaN   NaN
#
#
# # 数据合并值merge
# # merge:按照指定的列把数据按照一定的方式合并到一起
# print(\'*\' * 30)
# print(t3.merge(t4, left_on=\'Z\', right_on=\'V\'))  # left_on=right_on# 就相当于前面这个和后面这个相等的地方进行合并,默认how为inner
# #    W  X   Y   Z  Q  R  S  T   U   V
# # 0  8  9  10  11  6  7  8  9  10  11
#
# print(t3.merge(t4, left_on=\'Z\', right_on=\'V\', how=\'outer\'))  # 交集，通过nan补全
# #      W    X     Y     Z    Q    R    S    T     U     V
# # 0  0.0  1.0   2.0   3.0  NaN  NaN  NaN  NaN   NaN   NaN
# # 1  4.0  5.0   6.0   7.0  NaN  NaN  NaN  NaN   NaN   NaN
# # 2  8.0  9.0  10.0  11.0  6.0  7.0  8.0  9.0  10.0  11.0
# # 3  NaN  NaN   NaN   NaN  0.0  1.0  2.0  3.0   4.0   5.0
#
# print(t3.merge(t4, left_on=\'Z\', right_on=\'V\', how=\'left\'))  # 左边为准，通过nan补全
# #    W  X   Y   Z    Q    R    S    T     U     V
# # 0  0  1   2   3  NaN  NaN  NaN  NaN   NaN   NaN
# # 1  4  5   6   7  NaN  NaN  NaN  NaN   NaN   NaN
# # 2  8  9  10  11  6.0  7.0  8.0  9.0  10.0  11.0
# print(t3.merge(t4, left_on=\'Z\', right_on=\'V\', how=\'right\'))  # 右边为准，通过nan补全
# #      W    X     Y     Z  Q  R  S  T   U   V
# # 0  8.0  9.0  10.0  11.0  6  7  8  9  10  11
# # 1  NaN  NaN   NaN   NaN  0  1  2  3   4   5
#
#
# # 分组和聚合
# # grouped = df.groupby(by="columns_name")
# # grouped是一个DataFrameGroupBy对象，是可迭代的
# # grouped中的每一个元素是一个元组
# # 元组里面是（索引(分组的值)，分组之后的DataFrame）
#
# # DataFrameGroupBy对象有很多经过优化的方法
# # count : 很注重非NAN值的数量
# # sum ： 非NA值的和
# # mean ： 非NA值的平均值
# # median ： 非NA值的算数中位数
# # std,var : 无偏标准差和方差
# # min,max ： 非NA值的最小值和最大值

""" test4 pandas其他知识点 """
import numpy as np
import pandas as pd

# 生成一段时间序列
print(pd.date_range(start=\'20180105\', end=\'20180206\', freq=\'D\'))
# DatetimeIndex([\'2018-01-05\', \'2018-01-06\', \'2018-01-07\', \'2018-01-08\',
#                \'2018-01-09\', \'2018-01-10\', \'2018-01-11\', \'2018-01-12\',
#                \'2018-01-13\', \'2018-01-14\', \'2018-01-15\', \'2018-01-16\',
#                \'2018-01-17\', \'2018-01-18\', \'2018-01-19\', \'2018-01-20\',
#                \'2018-01-21\', \'2018-01-22\', \'2018-01-23\', \'2018-01-24\',
#                \'2018-01-25\', \'2018-01-26\', \'2018-01-27\', \'2018-01-28\',
#                \'2018-01-29\', \'2018-01-30\', \'2018-01-31\', \'2018-02-01\',
#                \'2018-02-02\', \'2018-02-03\', \'2018-02-04\', \'2018-02-05\',
#                \'2018-02-06\'],
#               dtype=\'datetime64[ns]\', freq=\'D\')

# 其中频率的更多缩写
# D   日历日
# B   每工作日
# H   每小时
# T   每分钟
# S   每秒
# L   每毫秒
# U   每微妙
# M   每月最后一个日历日
# BM  每月最后一个工作日
# MS  每月第一个日历日
# BMS 每月第一个工作日


# index = pd.date_range(start=\'20180102\', periods=10)  # periods表示周期
# # 在DataFrame中使用时间序列
# df = pd.DataFrame(index, range(10), columns=[\'w\'])
#
# # t4 = pd.DataFrame(np.arange(12).reshape((2, 6)), index=list(string.ascii_uppercase[:2]),
# #                   columns=list(string.ascii_uppercase[-10:-4]))
# print(df)
#
# # 把时间戳转换为DataFrame格式
# # df["timeStamp"] = pd.to_datetime(df["timeStamp"],format="")
# # print()
# #
# # format参数大部分情况下可以不用写，但是对于pandas无法格式化的时间字符串，我们可以使用该参数，比如包含中文
#
#
# # pandas重采样
# # 重采样： 指的是将时间序列从一个频率转化为另一个频率进行处理的过程，将高频率数据转化为低频率数据为降采样，低频率转化为高频率为升采样
# tt = pd.DataFrame(np.random.uniform(10,50,(100,1)),index=pd.date_range(start=\'20180508\',periods=100))
# print(tt)
# print(tt.resample(\'M\').mean())
# print(tt.resample(\'10D\').count())


""" test5 北京pm2.5处理实例"""
# coding=utf-8
import pandas as pd
from matplotlib import pyplot as plt

file_path = "BeijingPM20100101_20151231.csv"

df = pd.read_csv(file_path)

# 把分开的时间字符串通过periodIndex的方法转化为pandas的时间类型
period = pd.PeriodIndex(year=df["year"], month=df["month"], day=df["day"], hour=df["hour"], freq="H")
df["datetime"] = period
# print(df.head(10))

# 把datetime 设置为索引
df.set_index("datetime", inplace=True)

# 进行降采样
df = df.resample("7D").mean()
print(df.head())
# 处理缺失数据，删除缺失数据
# print(df["PM_US Post"])

data = df["PM_US Post"]
data_china = df["PM_Nongzhanguan"]

print(data_china.head(100))
# 画图
_x = data.index
_x = [i.strftime("%Y%m%d") for i in _x]
_x_china = [i.strftime("%Y%m%d") for i in data_china.index]
print(len(_x_china), len(_x_china))
_y = data.values
_y_china = data_china.values

plt.figure(figsize=(20, 8), dpi=80)

plt.plot(range(len(_x)), _y, label="US_POST", alpha=0.7)
plt.plot(range(len(_x_china)), _y_china, label="CN_POST", alpha=0.7)

plt.xticks(range(0, len(_x_china), 10), list(_x_china)[::10], rotation=45)

plt.legend(loc="best")

plt.show()