绘图
plt.plot(x,y)设置图片大小
plt.figure(figsize=(20,8),dpi=80) # figure图形图标的意思，在这里指的就是我们画的图 # 通过实例化一个figure并且传递参数，能够在后台自动使用该figure实例 # 在图像模糊的时候可以传入dpi参数，让图片更加清晰。设置x、y轴坐标文字。
plt.xticks(list(x)[::3],, rotation=90) # rotation是这是坐标轴文字显示旋转的状态。rotation=90是旋转90度。 plt.yticks(y)设置中文。因为matplotlib默认不显示中文。需要设置。
拷贝微软雅黑或黑体等中文字体文件至如下目录：
/Users/scrappy_zhang/anaconda3/lib/python3.6/site-packages/matplotlib/mpl-data/fonts/ttf/第一种。在Windows和Linux设置字体：通过matplotlib.rc修改
font = {'family': 'MicroSoft YaHei', 'weight': 'bold', 'size': 'larger'} matplotlib.rc('font',**font) # matplotlib.rc('font', family='MicroSoft YaHei',weight='bold',size='larger')第二种。在Windows、Linux和mac中，通过matplotlib.font_manager修改。
from matplotlib import font_manager my_font = font_manager.FontProperties(fname="字体路径") plt.xticks(list(x)[::3],, rotation=90,fontproperties=my_font)画多个线条。
font = font_manager.FontProperties('SimHei', size=10) y1 = [1,0,1,1,2,4,3,2,3,4,4,5,6,5,4,3,3,1,1,1] y2 = [1,0,3,1,2,2,3,3,2,1,2,1,1,1,1,1,1,1,1,1] x = [i for i in range(11,31)] plt.plot(x, y1, label='自己') plt.plot(x, y2, label='同桌') # 显示图例 # 只有这一处使用prop设置字体 plt.legend(prop=font)设置图例
# loc参数可以这是图例的位置，具体可以参考源码 plt.legend(prop=font, loc=0)显示网格
# alpha设置透明度 plt.grid(alpha=0.2)设置线条的颜色
plt.plot(x, y, label='', color='', linestyle='--', linewidth=5, alpha=0.5) 颜色风格字符r 红色- 实线g 绿色-- 虚线、破折线b 蓝色-. 点划线w 白线: 点虚线、虚线 留空或空格，无线条c 青色m 洋红y 黄色k 黑色#00ff00 16进制alpha=0.8 灰度值一个在python中做科学计算的基础库，重在数值计算，也是大部分python科学计算库的基础库，多用在大型、多维数组上执行数值运算。
numpy.astype(float)修改数组的类型
import numpy as np a = np.array([1,2,3,4,5,6], dtype='i4') print(a.dtype) print(a) b = a.astype(dtype='i8') print(b.dtype) print(b) >int32 >[1 2 3 4 5 6] >int64 >[1 2 3 4 5 6]reshape()：修改数组形状。
import numpy as np a = np.array([[1,2,3],[4,5,6]]) # reshape()有返回值，但对数据本身并不会产生影响。除非找一个变量接收返回值。 # 例如：a.reshape(),会产生新的形状，但a并没有变化。 b = a.reshape(3,2) print(a.shape) print(b.shape)多维数组转换为一维数组(1)。reshape()需要传入一个数据，就是数组元素的个数。
import numpy as np a = np.array([[1,2,3],[4,5,6]]) a = a.reshape((6,)) >>[1 2 3 4 5 6]多维数组转换为一维数组(2)。
import numpy as np a = np.array([[1,2,3],[4,5,6]]) a = a.flatten() print(a) >>[1 2 3 4 5 6]数组和数字的运算：数组中的每个元素都和数字进行计算。
数组和数组的运算：对应位置的元素进行计算。
多维数组和一维数组的计算(示例如下)：
1行6列的一维数组可以和多行6列的多维数组进行计算。6行1列的数组可以和6行多列的多维数组进行计算。 #要求:一维数组的行或列要与二维数组的行和列个数一致。 t1 = np.arange(0,6) t2 = np.arange(24).reshape(4,6) print(t2-t1) #t1 = np.arange(0,6) #t2 = np.arange(24).reshape(6,4) #t1 = t1.reshape(6,1) #print(t2-t1) >[[ 0 0 0 0 0 0] >[ 6 6 6 6 6 6] >[12 12 12 12 12 12] >[18 18 18 18 18 18]]多维数组与多维数组的计算
#如果数组的格式一样，即行和列数量一样。 #则在对应位置的元素进行计算。如果两个数组的后缘维度(trailing dimension，即从末尾开始算起的维度)的轴长度相符或其中一方的长度为1，则认为他们是广播兼容的。广播会在缺失和(或)长度为1的维度上进行。
可以把维度理解为shape()所对应的数字个数。
示例：
shape(3,3,3)的数组和(3,2)的数组能进行计算吗？
不能，(3,3,3)可以理解为数组为3个3行3列，(3,2)是3行2列数组，他们的行列数都不一样，无法对应起来。不能计算。
shape(3,3,2)和(3,2)的数组能计算吗？
能，(3,3,2)可以理解为数组为3个3行2列，(3,2)是3行2列数组，(3,2)可以在(3,3,2)中对应起来，也就是说后缘维度相符。可以计算。
在numpy中可以理解为方向，使用0,1,2…数字表示，对于一个一维数组，只有一个0轴，对于2维数组(shape(2,2))，有0轴和1轴，对于三维数组(shape(2,2,3))，有0,1,2轴。
有了轴的概念之后，我们计算会更加方便，比如计算一个2维数组的平均值，必须指定是计算哪个方向上面的数字的平均值。
np.loadtxt(frame,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)
参数解释frame文件、字符串或产生器，可以是.gz或bz2压缩文件dtype数据类型，可选，CSV的字符串以什么数据类型读入数组中，默认np.floatdelimiter分割字符串，默认是任何空格，改为逗号skiprows跳过前xx行，一般跳过第一行表头usecols读取指定的列，索引，元组类型unpack如果是True，读入属性将分别写入不同的数组变量，False读入数据只写入一个数组变量，默认为False。就是将行数据转换为列数据，行列互换。 import numpy as np file_path = './test.csv' res = np.loadtxt(file_path, delimiter=',', dtype='int') print(res)转置是一种变换，对于numpy中的数组来说，就是在对角线方向交换数据，目的也是为了更方便的去处理数据。以下是三种数据转置的方法。
t1.transpose()：
import numpy as np t1 = np.arange(24).reshape((4,6)) print(t1) print('*'*100) print(t1.transpose()) 结果： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23]] **************************************************************************************************** [[ 0 6 12 18] [ 1 7 13 19] [ 2 8 14 20] [ 3 9 15 21] [ 4 10 16 22] [ 5 11 17 23]]t1.swapaxes(1,0)：
import numpy as np t1 = np.arange(24).reshape((4,6)) print(t1) print('*'*100) # 交换两个轴 print(t1.swapaxes(1,0))t1.T：
import numpy as np t1 = np.arange(24).reshape((4,6)) print(t1) print('*'*100) print(t1.T)取单行数据（第三行数据）。
import numpy as np t1 = np.arange(24).reshape((4,6)) print(t1[2,:])取连续行的数据（第2行之后的所有数据）
import numpy as np t1 = np.arange(24).reshape((4,6)) print(t1[1:,:])取指定行的数据（第1、3、4行的数据）。
import numpy as np t1 = np.arange(24).reshape((4,6)) print(t1[[0,2,3],:])取单列的数据（第3列的数据）。
t1[:,2]取连续列的数据（第2列之后的数据）。
t1[:,1:]取指定列的数据（第2，3，5列数据）。
t1[:,[1,2,4]]取指定行列的数据（第3行第4列）。
t1[2,3]取多行和多列，取第2行到第4行，第3列到第5列的结果.
取的是行和列交叉的数据。
t1[1:4,2:5]取多个不相邻的点
#第二行第二列 #第三行第四列 #第一行第四列 t1[[1,2,0],[1,3,3]]指定位置值的修改。首先通过numpy索引获取到元素，在重新赋值，即可修改数值。
t1[2:4,3:5] = 0 结果： array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 0, 0, 17], [18, 19, 20, 0, 0, 23]])大于或小于某个值的修改。小于10的值都修改为3。
t1[t1<10] = 3###2.08、numpy中三元运算符
#t1中小于10的元素修改为0，大于10的元素修改为10 np.where(t1<10,0,10)注意：nan和inf都是float类型。
nan(NAN,Nan):not a number表示不是一个数字
什么时候会出现nan？
当我们读取本地文件为float时，如果有缺失，就会出现nan。当做了一个不合适的计算的时候（比如无穷大(inf)减去无穷大）inf(-inf.inf):infinity.inf表示正无穷，-inf表示负无穷
什么时候会出现inf包括(+inf,-inf)？
比如一个数字除以0，(python中直接会报错，numpy中是一个inf或者-inf)两个nan不相等。
#nan表示不是一个数字，但并不知道真实值是什么 np.nan == np.nan >Falsenp.nan != np.nan—>True
利用以上特性，判断数组中nan的个数。
np.count_nonzero(t1!=t1) #输出nan的个数np.isnan(t1)：
利用2的特性。
isnan()判断是否为nan，如果是则返回True。
np.isnan(t1) #在t1数组中nan的位置返回Truenan和任何数计算都为nan。
在一组数据中单纯的把nan替换为0，替换之后均值肯定会变小，所以一般的方式是把缺失的值替换为均值(中值)或者是直接删除有缺失值的一行。
求和：
t1.sum(axis=None)均值：受离群点的影响较大
t1.mean(a.axis=None)中值：
np.mediant(t.axis=None)最大值：
t1.max(axis=None)最小值：
t1.min(axis=None)极值：即最大值和最小值
np.ptp(t1,axis=None)标准差(std)：
t1.std(axis=None)标准差是一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值之间差异较大；一个较小的标准差，代表这些数值较接近平均值反映出数据的波动稳定情况，越大表示波动越大，越不稳定。
默认返回多维数组的全部统计结果，如果指定axis，则返回一个当前轴上的结果。
np.vstack((t1,t2))：竖直拼接，列数不变，增加行数。
import numpy as np t1 = np.arange(12).reshape(2,6) print(t1) print('*'*20) t2 = np.arange(12,24).reshape(2,6) print(t2) print('*'*20) print(np.vstack((t1, t2))) 结果： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] ******************** [[12 13 14 15 16 17] [18 19 20 21 22 23]] ******************** [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23]]np.hstack((t1,t2))：水平拼接，行数不变，增加列数。
import numpy as np t1 = np.arange(12).reshape(2,6) print(t1) print('*'*20) t2 = np.arange(12,24).reshape(2,6) print(t2) print('*'*20) print(np.hstack((t1, t2))) 结果： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] ******************** [[12 13 14 15 16 17] [18 19 20 21 22 23]] ******************** [[ 0 1 2 3 4 5 12 13 14 15 16 17] [ 6 7 8 9 10 11 18 19 20 21 22 23]]行交换：
import numpy as np t1 = np.arange(24).reshape(4,6) print(t1) print('*'*20) t1[[2,3], :] = t1[[3,2], :] print(t1) 结果： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23]] ******************** [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [18 19 20 21 22 23] [12 13 14 15 16 17]]列交换：
import numpy as np t1 = np.arange(24).reshape(4,6) print(t1) print('*'*20) # t1[[2,3], :] = t1[[3,2], :] t1[:, [1,3]] = t1[:, [3,1]] print(t1) 结果： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23]] ******************** [[ 0 3 2 1 4 5] [ 6 9 8 7 10 11] [12 15 14 13 16 17] [18 21 20 19 22 23]]numpy能够帮助我们处理数值,但是pandas除了处理数值之外（基于numpy）,还能够帮助我们处理其他类型的数据。
第一种创建方式。
index指定索引值，需要注意的是，索引的个数要和容器的个数一致。
import numpy as np import pandas as pd t1 = pd.Series(np.arange(6),index=list('abcdef')) 结果： a 0 b 1 c 2 d 3 e 4 f 5 dtype: int32第二种创建方式：利用字典创建。
temp_dict = {"name":"fdk","age":23,"tel":10086} t = pd.Series(temp_dict) print(t) 结果： name fdk age 23 tel 10086 dtype: object切片：直接导入start end 或者步长即可。
索引：一个的时候直接传入序号或者index，多个的时候传入序号或者index的列表。
#字典创建的，可以直接像操作字典一样来取值 t['name'] #普通的，可以直接通过索引来取 t[1] #取连续的多行 t[1:3] #取不连续的多行 t[[1,3]]或者t[['name','age']] #通过布尔来取 t[t>4]Series对象本质上由两个数组构成，一个数组构成对象的键（index, 索引）,一个数组构成对象的值（values），键–>值
ndarray的很多方法都可以运用与Series类型，比如argmax, clip
Series具有where方法，但是结果和ndarray不同。
读取的数据是个DataFrame类型的。
DataFrame对象既有行索引，又有列索引。
行索引，表明不同行，横向索引，叫index，0轴，axis=0。
列索引，表明不同列，纵向索引，叫columns，1轴，axis=1。
排序：
data = df.sort_values(by="排序依据", ascending=False) #ascending默认True，即升序排列，改为False即为降序。选择前20行的Row_Labels这一列。
df[:20]['Row_Labels']方括号写数组，表示取行，对行进行操作。
df['Row_Labels']写字符串，表示的取列索引，对列进行操作。
df[:20]如果取的单列，则这个单列的数据类型是Series类型。
df.loc：通过标签索引行数据。
print(t) #当前DataFrame的内容 w x y z a 0 1 2 3 b 4 5 6 7 c 8 9 10 11 #******************************** #选择单行单列 print(t.loc['a','w']) #输出 0 #******************************** #选择单行多列，多行单列颠倒位置即可 print(t.loc['a',['y','z']]) #输出 y 2 z 3 #******************************** #选择间隔的多行多列 print(t.loc[['a','c'],['x','z']]) #输出 x z a 1 3 c 9 11 #******************************** #选择连续行列的数据 print(t.loc['a':'c',['w','z']]) #输出 w z a 0 3 b 4 7 c 8 11 #冒号在loc中是闭合的，取值包括c #********************************df.iloc：通过位置获取行数据。
和loc操作一样，只是把标签索引换成了位置下标。
t.iloc[1:, :3]：表示取第二行之后，第四列之前的数据。
无论是loc还是iloc。都可以在取到值后进行重新赋值，即起到了修改数组值的作用。
注意点：不同条件之间需要使用括号括起来。
例如：查找使用次数超过800的狗的名字。
df[df['Count_AnimalName']>800]例如：查找查找使用次数超过800且小于1000的狗的名字。
df[(df['Count_AnimalName']>800)&(df[df['Count_AnimalName']<1000])]例如：查找查找使用次数超过800或小于1000的狗的名字。
df[(df['Count_AnimalName']>800)|(df[df['Count_AnimalName']<1000])]例如：查找查找使用次数超过800且名字长度大于4的狗的名字。
df[(df['Count_AnimalName'].str.len()>4)|(df[df['Count_AnimalName']>800])]df['Count_AnimalName'].str获取字符串
####3.04-5、pandas之字符串方法
方法说明cat实现元素级的字符串连接操作，可指定分隔符contains返回表示各字符串是否含有指定模式的布尔型数组count模式的出现次数endwith、startwith相当于对各元素执行x.endwith(pattern)或x.startwith(pattern)findall计算各字符串的模式列表get获取各元素的第i个字符join根据指定的分隔符将Series中各元素的字符串连接起来len计算各字符串的长度lower、upper转换大小写。相当于对各个元素执行x.lower()或x.upper()match根据指定的正则表达式对各个元素执行x.match()pad在字符串的左边、右边或者左右两边添加空白符center相当于pad(size=‘both’)repeat重复值。例如，s.str.repeat(3)相当于对各个字符串执行x*3replace用指定字符串替换找到的模式slice对Series中的各个字符串进行字串截取spilt根据分隔符或正则表达式对字符串进行拆分strip、rstrip、lstrip去除空白符，包括换行符。相当于对各个元素执行x.strip()、x.rstrip()、x.lstrip()数据缺失通常有两种情况：
一种是空，None等，在pandas是NaN(和np.nan一样)。另一种是值为0的。（看情况处理，有时0是有意义的）判断数据是否为NaN：pd.isnull(t)，pd.notnull(t)。两个正好相反。
处理方式：
直接删除NaN所在行：dropna(axix=0, how='any', inplace=False)。 how默认为any，即只要有NaN就删除，改为all，则是全为NaN才删除。inplace原地修改，如果为True，则说明修改的结果可以直接影响替换原来的值。如果为False，说明不是原地修改，修改的结果不影响原来的数据。 填充数据：t.fillna(t.mean()), t.fillna(t.median()), t.fillna(0)例如电影的平均分：
df['Rating'].mean()例如导演的人数：
temp_list = df['Actors'].str.split(',').tolist() nums = set([i for j in temp_list for i in j])例如电影时长的最大值最小值。
max_runtime = df['Runtime (Minutes)'].max() max_runtime_index = df['Runtime (Minutes)'].argmax() min_runtime = df['Runtime (Minutes)'].min() min_runtime_index = df['Runtime (Minutes)'].argmin() runtime_median = df['Runtime (Minutes)'].median()首先创建一个全0的二维数组，列名为分类，然后遍历每部小说，将小说对应的分类位置置为1。最后再统计每类的1的数量即可。
import pandas as pd import numpy as np from matplotlib import pyplot as plt from matplotlib import font_manager data = pd.read_csv('xiaoshuo.csv', delimiter=',') # 获取分类的列表 df = data['classify'].tolist() # 获取不重复的分类 df_clo = set(df) # 创建一个全0的数组 zeros = pd.DataFrame(np.zeros((data.shape[0], len(df_clo))), columns=df_clo) # 将小说对应的分类置为1 for i in range(data.shape[0]): zeros.loc[i, df[i]] = 1 # 统计各分类的小说数量 count = zeros.sum(axis=0) # 按照数量进行排序 count_sort = count.sort_values(ascending=False) # 设置中文字体 font = font_manager.FontProperties('SimHei', size=13) # 设置图像大小 plt.figure(figsize=(10,5), dpi=80) # 获取分类名称和对应的数量 _x = count_sort.index _y = count_sort.values # 画图 plt.bar(range(len(_x)), _y, width=0.5, color='c') # 设置对应的刻度 plt.xticks(range(len(_x)), _x, fontproperties=font) plt.ylim((0,15)) # 在图像中显示数量 for a, b in enumerate(_y): plt.text(a-0.2, b+0.5, '共{}部'.format(int(b)), fontproperties=font) plt.grid(alpha=0.5) plt.show()join：默认的情况下他是把行索引相同的数据合并到一起。
注意：如t1.join(t2)。所有的行数索引以前面一个数组为准，即以t1为准，t2少的行，增加上，值置为NaN。t2多的行直接剔除。
即：合并后的数组的index索引，以join前面的数组索引为标准。
t1的数据： A B C D 0 0 1 2 3 1 4 5 6 7 2 8 9 10 11 t2的数据 E F 0 0 1 1 2 3 2 4 5t1.join(t2)：结果
A B C D E F 0 0 1 2 3 0 1 1 4 5 6 7 2 3 2 8 9 10 11 4 5t2.join(t1)：结果
E F A B C D 0 0 1 0 1 2 3 1 2 3 4 5 6 7 2 4 5 8 9 10 11merge：按照指定的列索引把数据按照一定的方式合并到一起。
#数据准备 In [42]: t1 Out[42]: M N O P A 1.0 1.0 a 1.0 B 1.0 1.0 b 1.0 C 1.0 1.0 c 1.0 In [62]: t2 Out[62]: V W X Y Z A 0.0 0.0 c 0.0 0.0 B 0.0 0.0 d 0.0 0.0默认的合并方式inner，交集
In [66]: t1.merge(t2, left_on="O", right_on="X") Out[66]: M N O P V W X Y Z 0 1.0 1.0 c 1.0 0.0 0.0 c 0.0 0.0 # inner是默认的合并方式。 In [66]: t1.merge(t2, left_on="O", right_on="X", how="inner") Out[66]: M N O P V W X Y Z 0 1.0 1.0 c 1.0 0.0 0.0 c 0.0 0.0merge outer，并集，缺失部分NaN补全
In [67]: t1.merge(t2, left_on="O", right_on="X", how="outer") Out[67]: M N O P V W X Y Z 0 1.0 1.0 a 1.0 NaN NaN NaN NaN NaN 1 1.0 1.0 b 1.0 NaN NaN NaN NaN NaN 2 1.0 1.0 c 1.0 0.0 0.0 c 0.0 0.0 3 NaN NaN NaN NaN 0.0 0.0 d 0.0 0.0merge left：以左边的数组为参考
In [68]: t1.merge(t2, left_on="O", right_on="X", how="left") Out[68]: M N O P V W X Y Z 0 1.0 1.0 a 1.0 NaN NaN NaN NaN NaN 1 1.0 1.0 b 1.0 NaN NaN NaN NaN NaN 2 1.0 1.0 c 1.0 0.0 0.0 c 0.0 0.0merge right：以右边的数组为参考
In [69]: t1.merge(t2, left_on="O", right_on="X", how="right") Out[69]: M N O P V W X Y Z 0 1.0 1.0 c 1.0 0.0 0.0 c 0.0 0.0 1 NaN NaN NaN NaN 0.0 0.0 d 0.0 0.0参数解析：
left_on：指定左边数组的列索引。right_on：指定右边数组的列索引。how：选择连接方式，交、并或左、右参考。在pandas中类似的分组的操作有很简单的方法
grouped = df.groupby(by='columns_name') #grouped是一个DataFrameGroupBy对象，是可迭代的。 #可以调用聚合方法 #grouped中的每一个元素是一个元组 #元组里面是(索引(分组的值)，分组之后的DataFrame) for i,j in grouped: print(i,j) #i是国家分组，j是DataFrame对象，是这个国家的店铺的数据。####3.09-2、多条件分组
grouped = df['Brand'].groupby(by=[df['Country'],df['State/Province']]).count() #获取分组之后的某一部分数据。 #grouped = df.groupby(by=[df['Country'],df['State/Province']])['Brand'].count() #对某几列数据进行分组。 #grouped = df.groupby(by=[df['Country'],df['State/Province']]).count()['Brand'] #以上写法结果相同。 print(type(grouped))返回的数据类型是Series。
如果想要返回的数据是DataFrame类型呢？
#只需要在取列的时候，用两个方括号括起来即可：df[['Brand']] grouped = df[['Brand']].groupby(by=[df['Country'],df['State/Province']]).count() #其他的和Series一样。多条件分组，返回的数前两列都是索引，即复合索引。
####3.10-1、简单的索引操作
获取index：df.index指定index：df.index = ['x','y']重新设置index：df.reindex(list('abcdef'))，重新设置的index如果原来没有，就默认值为NaN，而且reindex并不会影响df本身的内容，除非重新赋值给df。指定某一列的值作为index：df.set_index('Country', drop=False)，drop默认为True，即将作为索引的列从列中删除。如果想要继续保留这列，则设为False。指定index的唯一值：df.set_index('Country').index_unique()，因为索引是可以重复的，所以unique去重。a数组
In [126]: a Out[126]: a b c d 0 0 7 one h 1 1 6 one j 2 2 5 one k 3 3 4 two l 4 4 3 two m 5 5 2 two n 6 6 1 two oDataFram的复合索引需要使用loc进行定位元素。
数组b = a.set_index(['c','d'])：结果为：
#这时，数组的数据类型是DataFrame In [130]: b Out[130]: a b c d one h 0 7 j 1 6 k 2 5 two l 3 4 m 4 3 n 5 2 o 6 1 如果想要取one,k对应的b列的值。b.loc['one'].loc['j','b']。数组c = b['a']：结果为：
In [135]: c Out[135]: c d one h 0 j 1 k 2 two l 3 m 4 n 5 o 6 Name: a, dtype: int64 c['one']['j']c['one','j']swaplevel()可以将复合索引进行交换。将内层索引换到外层，再进行取值。
数组d = a.set_index(['d','c'])['a']：结果为：
In [143]: d Out[143]: d c h one 0 j one 1 k one 2 l two 3 m two 4 n two 5 o two 6 Name: a, dtype: int64取one对应的值：swaplevel()交换水平的索引。d.swaplevel()后和b格式一样。就可以直接取了。
取内层索引
In [150]: d.swaplevel()['one'] Out[150]: d h 0 j 1 k 2 Name: a, dtype: int64###3.11、时间序列
start和end以及freq配合能够生成start和end范围内以频率freq的一组时间索引。
start和periods以及freq配合能够生成从start开始的频率为freq的periods个时间索引。
时间字符串转换为时间序列
df['timeStramp'] = pd.to_datetime(df['timeStramp'],format='') format参数大部分情况下可以不用写，但是对于pandas无法格式化的时间字符串，我们可以使用该参数，比如包含中文的。重采样：指的是将时间序列从一个频率转化为另一个频率进行处理的过程，将高频率数据转化为低频率数据为降采样，低频率转化为高频率为升采样。
pandas提高了一个resample的方法来帮助我们实现频率转化。
t.resample(‘M’).mean()
t.resample(‘10D’).count()
####3.11-5、PeriodIndex时间段转换
之前的DatetimeIndex可以理解为时间戳，你们PeriodIndex可以理解为时间段。
可以把分开的、零散的时间字符串通过PeriodIndex的方法进行组合，转化为pandas的时间序列。
periods = pd.PeriodIndex(year=data['year'],month=data['month'],day=data['day'],hour=data['hour'],freq='H')如果给这个时间段降采样呢？
data = df.set_index(periods).resample('10D').mean()