本文是参考一篇大神翻译pandas官方十分钟入门及官方pandas十分钟入门所写，加了一点自己的理解和注释，稍微丰富了一下前两篇佳作，实践版本 pandas_0.24
目录
1.1 通过传入一个列表数据创建一个Series，pandas默认会生成一个整形索引
1.2 通过传入一个numpy的数组，一个时间列表作为索引，和列标签来创建一个DataFrame
1.3 通过传入一个能够被转换成类似序列结构的字典对象来创建一个DataFrame：
1.5 如果您正在使用IPython，则会自动启用列名称（以及公共属性）的选项卡完成。以下是将要完成的属性的子集：
在实践之前需要导入以下几个模块。
#！/user/bin/python
#coding=utf-8
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['simhei']
1.0 创建对象
1.1 通过传入一个列表数据创建一个Series，pandas默认会生成一个整形索引
## 创建默认整数索引
s = pd.Series([1,3,5,np.nan,6,8])
print(s)
1.2 通过传入一个numpy的数组，一个时间列表作为索引，和列标签来创建一个DataFrame
## 通过传入numpy数组 ，创建带有日期索引和带有标记列的DataFrame
dates = pd.date_range('20190401',periods=8) # 生成从20190401开始的8 个数据
#### dates = pd.date_range(1/4/2019,periods=8) ##目的同上
print(dates)
df = pd.DataFrame(np.random.randn(8,5),index=dates,columns=['A','B','C','D','F'])
print(df)
## np.random.randn(8,5)生成8 行5 列的二位随机数组
1.3 通过传入一个能够被转换成类似序列结构的字典对象来创建一个DataFrame：
## 通过传入一个能够装换为类似序列结构的字典对象来创建 DataFrame
df2 = pd.DataFrame({'A':1.,
'B':pd.Timestamp('20190401'),
'C':pd.Series(1,index=list(range(4)),dtype='float32'),
'D':np.array(np.random.randint(1,10,4),dtype='int32'),
'E':pd.Categorical(['test','train','test','train']),
'F':'寒枫'})
print(df2)
1.4 查看每列的数据类型
## 查看每列的数据结构
# print(df2.dtypes)
1.5 如果您正在使用IPython，则会自动启用列名称（以及公共属性）的选项卡完成。以下是将要完成的属性的子集：
df2.A df2.bool
df2.abs df2.boxplot
df2.add df2.C
df2.add_prefix df2.clip
df2.add_suffix df2.clip_lower
df2.align df2.clip_upper
df2.all df2.columns
df2.any df2.combine
df2.append df2.combine_first
df2.apply df2.compound
df2.applymap df2.consolidate
df2.D
2. 查看数据
请参阅“ 基础”部分。
2.1 查看frame前面和后面的几行数据
## 打印数据开始两行
print(df.head(2))
## 打印数据结尾三行
print(df.tail(3)) # 默认打印五行
## 打印数据索引列
print(df.index)
## 打印数据列名
print(df.columns)
## 打印数据值
print(df.values)
## 打印数据简要统计摘要
print(df.describe())
'''
count 该列数据个数 ，mean ：该列的平均数值 std:该列的标准偏差
min : 该列的最小值，max : 该列的最大值
'''
2.2 数据转置
# ## 数据转置
# print(df.T)
2019-04-01 2019-04-02 2019-04-03 ... 2019-04-06 2019-04-07 2019-04-08
A -1.084281 0.794940 -1.465184 ... 0.018152 1.470079 -0.114246
B 0.187748 0.315691 -0.563132 ... -0.551774 0.335402 -1.601884
## 默认打印五行
2.3 排序
# 按照轴线进行排序 -- axis 表示以那个轴为基准 0 表示以行索引为基准，ascending表示是否降序排列
print(df.sort_index(axis=0,ascending=False))
## 按照列进行排序 -- by 表示以哪个列排序，ascending表示是否降序排列
print(df.sort_values(by = 'B',ascending=True))
3.数据查找(截取)
注意：虽然标准的Python / numpy的表达式选择和设置直观，派上用场的互动工作，为生产代码，官方建议优化的pandas数据访问方法，.at，.iat， .loc和.iloc。
请参阅索引文档索引和选择数据以及MultiIndex / Advanced索引。
3.1 获取数据
#### 数据查找
## 查找一列，返回一个Series数据
print(df.A[:3]) # 查找df中A列中第1 至 三 行
print(df['A'][1:3]) # 查找A列中第二行到第三行
## 按行查找 第一行至第三行
print(df[:3])
# 按索引查找 从20190402至20190405
print(df['20190402':'20190405'])
# 按照索引获取一行
print(df.loc[dates[0]])
# 通过索引，在多轴上进行数据查找
print(df.loc[:,['A','C','D']]) ## 查找全量数据A\C\D轴数据
print(df.loc['20190402':'20190405',['A','C','D']]) ## 查找索引在20190402-2090405之间的数据A\C\D轴数据
print(df.loc['20190401',['A','B']]) ## 查找索引是20190401的A、B列
print(df.loc[dates[0],'A']) ## 查找第一个索引的A列 标量
print(df.at[dates[0],'A']) ## 作用同上
print(df.iloc[3]) ##查找第四行数据
print(df.iloc[[1,2,4],[0,2]]) ## 查找第2、3、5行第1、3列数据
print(df.iloc[1:3,0:2]) ## 查找第2-4行的第1 - 2 行数据
print(df.iloc[1,1]) ## 查找第二行第二列标量值
print(df.iat[1,1]) ## 目的同上
#### 通过布尔方式查找
print(df.A > 0) ## 查找A列是否大于0
print(df[df.A > 0]) ##查找A列大于0 的数据行
print(df[df > 0]) ##查找DateFarm数据中大于0 的数据 ，小于0 的小时NAN
3.2 设置、修改标量值
# 生成一个新的数列 ，通过索引自动排列
daf = pd.Series([1,2,3,7,6,8],index=pd.date_range('20190402',periods=6))
print(daf)
# 将daf作为df的'F'列
df['F'] = daf
print(df)
## 通过标签修改值
df.at[dates[0],'A'] = 99
print(df.head(2))
## 通过位置修改值
df.iat[1,1] = 99
print(df.head(3))
## 通过numpy 数组设置一组新值
df.loc[:,'C'] = np.array([88]*len(df))
print(df)
## 通过where 操作修改值
df2 = df.copy()
df2[df2 >0]=-df2 ## 将df2中大于0 的值取反 ，小于0 的不变
print(df2)
2019-04-02 1
2019-04-03 2
2019-04-04 3
2019-04-05 7
2019-04-06 6
2019-04-07 8
Freq: D, dtype: int64
A B C D F
2019-04-01 -0.545616 1.248912 0.427845 0.207178 NaN
···
2019-04-08 1.164562 -0.222151 0.294118 -0.175625 NaN
A B C D F
2019-04-01 99.000000 1.248912 0.427845 0.207178 NaN
2019-04-02 0.900834 -0.544375 0.680875 -0.146986 1.0
A B C D F
2019-04-01 99.000000 1.248912 0.427845 0.207178 NaN
2019-04-02 0.900834 99.000000 0.680875 -0.146986 1.0
2019-04-03 -0.616396 -0.078812 0.223310 -0.140213 2.0
A B C D F
2019-04-01 99.000000 1.248912 88 0.207178 NaN
2019-04-02 0.900834 99.000000 88 -0.146986 1.0
···
2019-04-07 0.076668 -0.417550 88 1.458041 8.0
2019-04-08 1.164562 -0.222151 88 -0.175625 NaN
A B C D F
2019-04-01 -99.000000 -1.248912 -88 -0.207178 NaN
2019-04-02 -0.900834 -99.000000 -88 -0.146986 -1.0
···
2019-04-07 -0.076668 -0.417550 -88 -1.458041 -8.0
2019-04-08 -1.164562 -0.222151 -88 -0.175625 NaN
4. 缺失数据处理 （fillna失效问题）
#### Reindexing 允许在指定轴上修改、增加或删除索引，结果返回一个原始数据的拷贝
df1 = df.reindex(index=dates[:4],columns = list(df.columns)+['H'])
print(df1)
df1.loc[dates[0]:dates[1],'H'] = 77 ## 没设置的默认会填充nan
print(df1)
## 查找没有任何数据丢失的数据行
print(df1.dropna(how='any'))
## 给所有丢失的数据设置新值
df1.fillna(value=5) ## 不起作用，搞不懂···
## 修改为fillna（0，inplace = True）
print(df1)
## 判断缺失值位置
print(pd.isna(df1))
## 通过以下方式实现df.fillna（value = 22 ）, 将缺失值替补为22
df1[pd.isna(df1)] = 22
print(df1)
5.操作
5.1 统计 操作通常不包括缺失值的
## 列均值 .mean 默认以列索引轴求均值 默认0 1 为按照行索引
print(df.mean())
## 行均值
print(df.mean(1))
## 不同维度的pandas对象运算 ，shift 对齐操作
## 第三个索引开始匹配数组，匹配不到的用nan补齐，做缺失处理
s = pd.Series([1,2,5,np.nan,6,8,8,9],index=dates).shift(2)
print(s)
print(df.sub(s,axis = 'index')) # 对不同维度进行减法操作，用df 中没一列与S 对应进行相减操作
结果值：
A -0.600197
···
F 0.583930
dtype: float64
2019-04-01 -0.095180
2019-04-02 0.086444
···
2019-04-08 -0.640097
Freq: D, dtype: float64
2019-04-01 NaN
···
2019-04-08 8.0
Freq: D, dtype: float64
A B C D F
2019-04-01 NaN NaN NaN NaN NaN
···
2019-04-08 -10.059705 -6.586239 -8.876765 -8.348272 -9.329505
5.2 Apply
## apply 对DataFrame 进行函数方法操作 aooly(函数方法)
print(df.head(3))
print(df.apply(np.cumsum).head(3)) # 累加方法，第I 行J 列的值为df[0,j]+...+df[i,j]
print(df.apply(lambda x : x.max() - x.min())) ## 取每一列最大值减最小值
结果值：
A B C D F
2019-04-01 -0.440639 0.712953 0.971021 -1.981606 0.262369
2019-04-02 -0.422267 -1.155813 -0.173556 1.228704 0.955155
2019-04-03 1.740994 -1.306589 0.392031 0.055054 2.349670
A B C D F
2019-04-01 -0.440639 0.712953 0.971021 -1.981606 0.262369
2019-04-02 -0.862906 -0.442860 0.797465 -0.752902 1.217524
2019-04-03 0.878088 -1.749449 1.189496 -0.697848 3.567193
A 3.800699
···
F 3.679175
dtype: float64
5.3 直方图
#### 直方图
s = pd.Series(np.random.randint(0,8,50))
print(s)
print(s.value_counts()) ## 统计出现数字个数
print(s.mode()) ## DataFrame 求出现次数最多的值
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['simhei']
# plt.plot(s,label='值为:{}'.format(s))
plt.hist(s,np.arange(0,9,1),label='个数据个数：\n{}'.format(s.value_counts()),histtype = 'bar',rwidth=0.8)
plt.legend()
plt.show()
结果值：
0 7
1 4
······
48 3
49 7
dtype: int32
6 11
····
0 4
dtype: int64
0 6
dtype: int32
5.4 字符串方法
Series在str 属性中配备了一组字符串处理方法，可以轻松地对数组的每个元素进行操作，如下面的代码片段所示。请注意，str中的模式匹配通常默认使用正则表达式（在某些情况下总是使用它们）。在Vectorized String Methods中查看更多信息。
## 将DataFrame 中英文字符改为小写
s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', '狗', 'cat'])
print(s.str.lower())
6.数据合并
andas提供了各种工具，可以轻松地将Series，DataFrame和Panel对象与各种设置逻辑组合在一起，用于索引和关联代数功能（在连接/合并类型操作的情况下）。
请参阅合并部分。
戳这儿，看他人详解数据合并：python数据表的合并 join() 、merge()和concat()的用法
#### 数据合并
## concat()
df = pd.DataFrame(np.random.randn(10,4))
print(df)
pieces = [df[:3],df[3:7],df[7:8]] ## 从df中截取三段数据，形成一个包含三个DataFream的数据
print(pd.concat(pieces)) ## 将pieces中三个DataFrame拼接为一个dataFrame
print(pd.concat([pieces[0],pieces[1],pieces[2]])) ## 作用同上
## merge
left = pd.DataFrame({'key':['foo','foo'],'lval':[1,2]})
right = pd.DataFrame({'key':['foo','foo'],'lval':[4,5]})
print('这里是left :\n{}\n这里是right :\n{}'.format(left,right))
# 按照key为键进行合并，类似于SQL风格合并
print(pd.merge(left,right,on='key'))
left = pd.DataFrame({'key':['foo','bar'],'lval':[1,2]})
right = pd.DataFrame({'key':['foo','bar'],'lval':[4,5]})
print('这里是left :\n{}\n这里是right :\n{}'.format(left,right))
# 按照key为键进行合并，类似于SQL风格合并
print(pd.merge(left,right,on='key'))
## append()
## 截取df中第3 - 5 行
df = pd.DataFrame(np.random.randn(8, 4), columns=['A', 'B', 'C', 'D'])
s = df.iloc[3:6]
print(df.append(s,ignore_index=True)) ## 新增时忽略索引值
结果值：
0 1 2 3
0 -2.514797 -0.166914 -1.155283 -1.204279
···
9 0.632926 -1.440024 0.563318 -1.509210
0 1 2 3
0 -2.514797 -0.166914 -1.155283 -1.204279
···
7 0.890460 -0.145132 -0.505524 -1.680901
0 1 2 3
0 -2.514797 -0.166914 -1.155283 -1.204279
···
7 0.890460 -0.145132 -0.505524 -1.680901
这里是left :
key lval
0 foo 1
1 foo 2
这里是right :
key lval
0 foo 4
1 foo 5
key lval_x lval_y
0 foo 1 4
1 foo 1 5
2 foo 2 4
3 foo 2 5
这里是left :
key lval
0 foo 1
1 bar 2
这里是right :
key lval
0 foo 4
1 bar 5
key lval_x lval_y
0 foo 1 4
1 bar 2 5
A B C D
0 1.528914 -3.178597 -1.388341 -0.578449
···
10 -0.108184 0.521411 -0.945769 -1.599539
7.Grouping(组操作)
## Grouping 组操作
# 根据某些标准将数据拆分为组 splitting
# 将功能独立应用于每个组 applying
# 将结果组合成数据结构 Combining
df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three','two', 'two', 'one', 'three'],
'C': np.random.randn(8),
'D': np.random.randn(8)})
print(df)
# 根据条件分组，并且把分组的结果进行求和
print(df.groupby('A').sum()) # 先根据A进行分组，分为foo和bar两组，把两组的结果进行求和
# 根据多个列进行分组，形成一个多级索引，并执行函数
print(df.groupby(['A','B']).sum()) # 先根据A分组，再根据B分组然后将结果进行求和操作
8.Reshaping
#### reshaping 重塑
tuples = list(zip(*[['bar', 'bar', 'baz', 'baz','foo', 'foo', 'qux', 'qux'],
['one', 'two', 'one', 'two','one', 'two', 'one', 'two']]))
print(tuples)
index = pd.MultiIndex.from_tuples(tuples,names=['first','second'])
print(index)
df = pd.DataFrame(np.random.randn(8,2),index=index,columns=['A','B'])
print(df)
print(df[:4])
# stack() stack()方法“压缩”DataFrame列级别中的数据进行压缩。
stacked = df.stack()
print(stacked)
# unstack() unstack()方法 '解压缩'
# 使用“堆叠”DataFrame或Series（具有MultiIndexas index），stack()is 的逆操作，unstack()默认情况下取消堆叠最后一级：
print(stacked.unstack()) # 默认按照最后一列进行解压缩 可传参，指定解压缩列
结果值：
[('bar', 'one'), ('bar', 'two'), ('baz', 'one'), ('baz', 'two'), ('foo', 'one'), ('foo', 'two'), ('qux', 'one'), ('qux', 'two')]
MultiIndex(levels=[['bar', 'baz', 'foo', 'qux'], ['one', 'two']],
codes=[[0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 0, 1, 0, 1, 0, 1]],
names=['first', 'second'])
A B
first second
bar one 0.213350 -1.216762
two -0.205286 -2.191666
baz one 1.380801 1.683300
two -0.055559 -0.187650
foo one 0.088255 0.341057
two 1.308803 -0.133551
qux one -0.476044 -0.410808
two 0.588700 -0.509348
A B
first second
bar one 0.213350 -1.216762
two -0.205286 -2.191666
baz one 1.380801 1.683300
two -0.055559 -0.187650
first second
bar one A 0.213350
B -1.216762
two A -0.205286
B -2.191666
baz one A 1.380801
B 1.683300
two A -0.055559
B -0.187650
foo one A 0.088255
B 0.341057
two A 1.308803
B -0.133551
qux one A -0.476044
B -0.410808
two A 0.588700
B -0.509348
dtype: float64
A B
first second
bar one 0.213350 -1.216762
two -0.205286 -2.191666
baz one 1.380801 1.683300
two -0.055559 -0.187650
foo one 0.088255 0.341057
two 1.308803 -0.133551
qux one -0.476044 -0.410808
two 0.588700 -0.509348
# ## 数据透视表
import datetime
df = pd.DataFrame({'A': ['one', 'one', 'two', 'three'] * 6,
'B': ['A', 'B', 'C'] * 8,
'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 4,
'D': np.random.randn(24),
'E': np.random.randn(24),
'F': [datetime.datetime(2019, i, 1) for i in range(1, 13)] + [datetime.datetime(2019, i, 15) for i in range(1, 13)]})
print(df)
print(pd.pivot_table(df,values='D',index=['A','B'],columns=['C'])) # 默认取均值
print(pd.pivot_table(df,values='D',index=['A','B'],columns=['C'],
aggfunc=np.sum)) #分组求和
# 结果对象是DataFrame在行和列上具有潜在的分层索引。如果values未给出列名，则数据透视表将包含可在列中的其他层次结构中聚合的所有数据：
print(pd.pivot_table(df, index=['A', 'B'], columns=['C']))
结果值：
D:\wenjian\Anaconda3\python.exe D:/PycharmWorkSpace/matplotlibTest/pandasTest/DataFrame.py
A B C D E F
0 one A foo -1.163767 -0.161156 2019-01-01
····
22 two B bar 0.216646 0.728224 2019-11-15
23 three C bar -0.521139 0.035026 2019-12-15
C bar foo
A B
one A -0.227452 -1.758839
B 0.252430 0.890363
C 0.422553 -1.587720
three A -0.370935 NaN
B NaN 0.242766
C -0.265546 NaN
two A NaN -0.078082
B -0.305072 NaN
C NaN 0.334943
C bar foo
A B
one A -0.454905 -3.517679
B 0.504860 1.780725
C 0.845107 -3.175440
three A -0.741870 NaN
B NaN 0.485531
C -0.531092 NaN
two A NaN -0.156164
B -0.610144 NaN
C NaN 0.669886
D E
C bar foo bar foo
A B
one A -0.227452 -1.758839 0.986109 -0.204844
B 0.252430 0.890363 0.820308 0.305939
C 0.422553 -1.587720 -0.237168 0.847675
three A -0.370935 NaN -1.553291 NaN
B NaN 0.242766 NaN 0.578002
C -0.265546 NaN -0.286240 NaN
two A NaN -0.078082 NaN -0.609020
B -0.305072 NaN 0.705481 NaN
C NaN 0.334943 NaN 1.018042
9.时间序列
pandas具有简单，强大且高效的功能，用于在频率转换期间执行重采样操作（例如，将第二数据转换为5分钟数据）。这在财务应用程序中非常常见，但不仅限于此。请参阅时间序列部分。
#！ /user/bin/python
# coding=utf-8
import pandas as pd
import numpy as np
rng = pd.date_range('1/4/2019 00:00',periods=5,freq='D')
'''
freq 以哪种方式累增 D：以日累增 ，S：以秒累增 ,M:以月累增 Q-NOV:以季度累增
'''
ts = pd.Series(np.random.randn(len(rng)),rng)
print(ts)
ts_utc = ts.tz_localize('UTC') # 转换时间，显示格式
print(ts_utc) # 打印年月日时分秒
print(ts_utc.tz_convert('US/Eastern')) # 时区转换
rng = pd.date_range('20190101',periods=5,freq='M')
ts = pd.Series(np.random.randn(len(rng)),index=rng)
print(rng) # 显示年月日（日为当月最后一天）
ps = ts.to_period() # 显示年月
print(ps)
print(ps.to_timestamp()) # 显示年月日（日为当月第一天）
### 以季度创建时间DataFrame
prng = pd.period_range('2012Q1','2022Q4',freq='Q-NOV')
ts = pd.Series(np.random.randn(len(prng)),index=prng)
print(prng) # 显示年月日（）
ts.index = (prng.asfreq('M','e')+1).asfreq('H','s')+9
print(ts.head(2))
结果值：
2019-01-04 -0.510788
2019-01-05 -0.757877
2019-01-06 0.571110
2019-01-07 1.113815
2019-01-08 -0.483230
Freq: D, dtype: float64
2019-01-04 00:00:00+00:00 -0.510788
2019-01-05 00:00:00+00:00 -0.757877
2019-01-06 00:00:00+00:00 0.571110
2019-01-07 00:00:00+00:00 1.113815
2019-01-08 00:00:00+00:00 -0.483230
Freq: D, dtype: float64
2019-01-03 19:00:00-05:00 -0.510788
2019-01-04 19:00:00-05:00 -0.757877
2019-01-05 19:00:00-05:00 0.571110
2019-01-06 19:00:00-05:00 1.113815
2019-01-07 19:00:00-05:00 -0.483230
Freq: D, dtype: float64
DatetimeIndex(['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',
'2019-05-31'],
dtype='datetime64[ns]', freq='M')
2019-01 -0.862710
2019-02 -0.499873
2019-03 -1.043634
2019-04 -0.060248
2019-05 0.335018
Freq: M, dtype: float64
2019-01-01 -0.862710
2019-02-01 -0.499873
2019-03-01 -1.043634
2019-04-01 -0.060248
2019-05-01 0.335018
Freq: MS, dtype: float64
PeriodIndex(['2012Q1', '2012Q2', '2012Q3', '2012Q4', '2013Q1', '2013Q2',
'2013Q3', '2013Q4', '2014Q1', '2014Q2', '2014Q3', '2014Q4',
'2015Q1', '2015Q2', '2015Q3', '2015Q4', '2016Q1', '2016Q2',
'2016Q3', '2016Q4', '2017Q1', '2017Q2', '2017Q3', '2017Q4',
'2018Q1', '2018Q2', '2018Q3', '2018Q4', '2019Q1', '2019Q2',
'2019Q3', '2019Q4', '2020Q1', '2020Q2', '2020Q3', '2020Q4',
'2021Q1', '2021Q2', '2021Q3', '2021Q4', '2022Q1', '2022Q2',
'2022Q3', '2022Q4'],
dtype='period[Q-NOV]', freq='Q-NOV')
2012-03-01 09:00 0.907065
2012-06-01 09:00 1.351146
Freq: H, dtype: float64
10. 分类
从0.15版本开始，pandas可以在DataFrame中支持Categorical类型的数据，参看：categoricalintroduction和APIdocumentation
pandas 可以在a中包含分类数据DataFrame。有关完整文档，请参阅 分类简介和API文档。
#！ /user/bin/python
# coding=utf-8
import pandas as pd
import numpy as np
df = pd.DataFrame({"id":[1,2,3,4,5,6], "raw_grade":['a', 'b', 'b', 'a', 'a', 'e']})
print(df)
#### 将原始的grade转换为Categorical数据类型
df['grade'] = df['raw_grade'].astype('category')
print(df['grade'])
#### 重新命名
df['grade'].cat.categories = ["very good", "good", "very bad"]
print(df['grade'])
# df['grade'] = df['raw_grade'].astype('category')
# print(df['grade'])
#### 对类别重新进行排序，并增加确实的类别
df['grade'] = df['grade'].cat.set_categories(["very bad", "bad", "medium", "good", "very good"])
print(df)
#### 根据分类顺序进行排序，不根据字典顺序
print(df.sort_values(by='grade'))
#### 根据分类进行分组，包括空类
print(df.groupby('grade').size())
结果值：
0 1 a
1 2 b
2 3 b
3 4 a
4 5 a
5 6 e
0 a
1 b
2 b
3 a
4 a
5 e
Name: grade, dtype: category
Categories (3, object): [a, b, e]
0 very good
1 good
2 good
3 very good
4 very good
5 very bad
Name: grade, dtype: category
Categories (3, object): [very good, good, very bad]
id raw_grade grade
0 1 a very good
1 2 b good
2 3 b good
3 4 a very good
4 5 a very good
5 6 e very bad
id raw_grade grade
5 6 e very bad
1 2 b good
2 3 b good
0 1 a very good
3 4 a very good
4 5 a very good
grade
very bad 1
bad 0
medium 0
good 2
very good 3
dtype: int64
11.绘图（单线图、多单线图）
请参阅绘图文档。
#！ /user/bin/python
# coding=utf-8
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['simhei']
plt.rcParams['axes.unicode_minus'] = False
#### 生成单线图
ts = pd.Series(np.random.randn(1000),index=pd.date_range('20190101',periods=1000))
print(ts)
ts = ts.cumsum() # 将数据进行累加
print(ts)
ts.plot(label='时间曲线',color='orange')
plt.legend()
plt.show()
#### 生成多线图
dfs = pd.DataFrame(np.random.randn(1000,4),
index=pd.date_range('20190101',periods=1000),
columns=['A','B','C','D'])
dfs = dfs.cumsum()
dfs.plot()
plt.legend()
plt.show()
12.数据的存取
#! /user/bin/python
# coding=utf-8
import pandas as pd
import numpy as np
import os
import matplotlib.pyplot as plt
path = os.getcwd()
dataDir = os.path.join(path,'data')
filePath = os.path.join(dataDir,'dfs.csv')
jpgPath = os.path.join(dataDir,'多曲线时间随机画图.jpg')
print(filePath)
dfs = pd.DataFrame(np.random.randn(1000,4),
index=pd.date_range('20190101',periods=1000),
columns=['A','B','C','D'])
# dfs.to_csv(filePath)
dfs.to_excel(os.path.join(dataDir,'dfs.xlsx'))
dfs = dfs.cumsum()
dfs.plot()
plt.legend()
# plt.savefig(jpgPath) ## 保存生成图片
plt.show()
df1 = pd.read_csv(filePath)
print(df1)
# df1 = pd.read_hdf(filePath,'df')
print(df1)
df2 = pd.read_excel(os.path.join(dataDir,'dfs.xlsx'))
print(df2)
小弟知识面浅陋，文章还有很多遗漏之处，欢迎留言批评指正或探讨更佳方法实现。
2007
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
