【2019】python3基础

2019python3基础

• python默认编码格式ASCII格式
  • #coding=utf-8

基础

1. 变量类型

• 五个标准数据类型（内置数据结构类型）
  • 数字Numbers
  • 字符串String
  • 列表List
  • 元组Tuple
  • 字典Dictionary

序列a通用操作	解释
子元素 in a	判断是否包含
元素 not in a
a + a	序列 链接
a * 6	序列 重复
a.index(‘子元素’)	返回 子元素的 index
a[0]	索引
a[:]	切片
a[::-1]	步长
min(),max(),sum(),len()	通用函数

字符串

• str常用功能	解释
  s1.replace(‘子元素’,‘替换为’,‘替换几次’)	不填次数，就会全替换
  s.split(’ ')	拆分，为list
  s1.join(s2)	用s2中元素链接s1中各元素
  s.startswith(‘str’)	判断，是否以str开头
  s.endswith(‘str’)	判断，是否以str结尾
  s.upper()	全大写
  s.lower()	全小写
  s.swapcase()	大小写互换
  s.capitalize()	首字母大写
  s.isnumeric()	判断，字符串是否只包含数字
  s.isalpha()	判断，字符串是否至少有一个字符，且字符都是字母
  s.rstrip()	删除字符末尾的空格

%格式化字符串

a = 'demo'
b = '%s is 样本' %a 
# %s 表示在这里要插入一个变量（字符串）
# %a 代表我们插入的变量是a

x = 4
y = 'haha'
z = 4.2
print('this is %i' %x)
print('this is %s' %y)
print('this is %f' %z)
print('this is %.2f' %z) # 输出2位小数，四舍五入
print('this is %.0f' %z) # 不四舍五入，直接切掉小数部分
print('this is %.2f' %x) # 

df['col1'].apply(lambda x:"%.2f%%"%(x*100)) # 转换为百分数
df.style.format({'col1':'{:.2%}'}) # 列转换为百分数

• str格式化	解释
  %i	整型
  %+i	显示正号
  '%.2f '% -0.01	负数会直接显示负号
  %.0f	不四舍五入，直接切掉小数部分
  %f	浮点型
  %.2	保留2位小数，四舍五入
  %.2e	科学计数法
  %.4E	科学计数法
  %g	小数位数少时，自动识别为浮点数 数据复杂时，自动识别为科学计数法
  %s	字符型
  %%	%

format格式化

• .format()，生成新的字符串

• str1.format格式化	解释
  "User ID:{0}".format('demo')	{}：占位符，其中数字可有可无
  "{}哈哈{}".format('a','b')	其中数字可有可无
  "{}{}{}".format('a','b','c')	不含数字时
  "{0}{1}{2}{0}".format('a','b','c')	含数字：明确了指定
  "我的工作时{work}".format(work='数据分析师')	变量指示（不一定是数字）
  "{:f}".format(3.1415)
  "{:.2f}".format(3.1415)	保留2位
  "{:e}".format(3.1415)	科学计数法
  "{:.0f}".format(3.1415)	取整，不四舍五入
  "{:%}".format(3.1415)	转为百分数
  "{:d}".format(10)	整数

标识符

_foo	不能直接访问的类属性	通过类提供的接口进行访问 不能有from xx import *导入
__foo	私有成员
_foo_	代表python里特殊方法专用的标识

print输出

• print默认是换行输出

  • 变量末尾加逗号，实现不换行输出

  • # 换行输出
    print('a')
    print('b')
    
    # 不换行输出
    print(x,y)
    
    # 不换行输出
    print(x),
    print(y),
    

• str格式化

  print('我今年%.2f岁，生于%i月' % (1,2))
  

apply,map,applymap

• map

  • 将函数套用到Series上的每个元素

• 根据字典key与col值相同，将value替换

  a = {'col1_value1':'aa','col1_value2':'bb'}
  df['col1'].map(a)#col1列中值，与dictionary的key相同的，变为对应values
  

• apply

  • 将函数套用到DataFrame上的行和列

  • 函数和自定义函数

    df['col'].apply(str.upper)
    df['col'].apply(自定义函数)
    
    def foo(x):
        a = str(x)='_a'
        return a
    def.index.apply(foo)
    

  • 匿名函数

    df.apply(lambda x:x.max() - x.min())
    df.apply(lambda x:x.max() - x.min(), axis=1)
    

  • 各列 分组 统计

    df.apply(pd.value_counts).fillna(0)
    

• applymap

  • 将函数套用到DataFrame上每个元素（elementwise）

  • str格式化

    df.applymap(lambda x:'.2f'%x)
    

表达式

• [str(x) for x in np.arange(10)] # 方法一
  list(map(str,np.arange(10))) # 方法二
  

Numpy

1 随机数

随机数	解释
np.random.normal(loc, scale, size)	正态分布 loc：均值 scale：标准差
np.random.rand()	均匀分布 [0,1)之间的
np.randm.randn()	标准正态分布
np.random.randint(100,200,10)	随机整数
np.random.seed(1)	种子
np.random.uniform(low,high,size)	均匀分布 [low,high)
np.random.poisson(lams,ize)	泊松分布 lam随机事件发生概率
np.random.choice(a[,size,replace,p])	从一维数组a中以概率p抽取元素 形成size形状新数组 replace表示是否可以重用元素
np.random.choice(b,(3,2),p = b/np.sum(b))

Pandas

1 表格样式

• 按元素修改字体样式

  # 小于0的元素，红色字体
  def colors(val):
      if val>48000:
          color='red'
      else:
          color='black'
      return('color:%s'%color)
  df[['col']].style.applymap(colors)
  

• 按行列修改背景样式

  # 最大值的背景高亮显示
  def highlight_max(s):
      is_max = s == s.max()
      lst=[]
      for v in is_max:
          if v:
              lst.append('background-color:yellow')
          else:
              lst.append('')
      return(lst)
  
  df.style.apply(highlight_max,axis=0)# 每列最大值
  df.style.apply(highlight_max,axis=1,subset=['col1','col2'])# 两列对比，每行的最大值
  

  • subset参数
    • 相较于df[[‘col’]].style.，subset会显示整张表

• 样式的索引和切片

  df.style.apply(highlight_max,subset=pd.IndexSlice[:2,:10])
  

• 按百分数显示

  df.style.format('{:.2%}',subset=['col1','col2'])
  

  • .format(’{:.2%}’,subset=[‘col1’,‘col2’])
    • 对col1,col2列的值，转换为百分数
    • 是转换，不单单是添加个百分号

• 指定每列，转换显示类型

  df.style.format({'col1':'{:.2%}','col2':'{+.2f}','col3':'{.4f}'，'col':'{:d}'})
  #对应列转换为百分数、显示正号的2位浮点数、四位浮点数、整数（转换为整数时，需要该列整型，而不是浮点型）
  

  • 一次转换为
    • 百分数
    • 显示正号，保留2位的浮点数
    • 四位小数点浮点数
    • 整数
      • 注意，转换为整数时，前提需要该列为int型——即可这种用法无意义（也许我的理解有误）

• 缺失值

  df.style.highlight_null(null_color='red')
  

  • 缺失值背景红色高亮

• 极值高亮显示

  df.style.highlight_max()
  df.style.highlight_min()
  

• 色彩映射

  df.style.background_gradient()
  df.style.background_gradient(cmap='Greens',axis=1,low=0,high=1)
  

  • cmap
    • 颜色
  • axis
    • 0：该列的元素间比较
    • 1：该行的元素间比较
  • low、high
    • 设置颜色区间
    • 类似热力图右侧颜色区间

• 条形图

  df.style.bar(subset=['col1','col2'],color='#d65f5f',width=100)
  

  • width
    • 最长的占格子的比例

• 分断式构建样式

  df.style.\
      highlight_min().\
      bar(color='#d65f5f',width=100,subset=['col5','col6']).\
      bar(color='#333333',subset=['col1','col2'],width=80)
  

  • 末尾添加.\
    • 只要不是最后一个样式，末尾添加.\
    • 且.\不能有空格和注释

---

2 Series

• 创建

  • 字典创建
  • 一维数组创建
  • 通过标量创建

  s=pd.Series(data=None, 
            index=None, 
            dtype=None,# np.str，object（字符串型）等
            name=None,
            copy=False,
            fastpath=False)
  pd.Series(10,index=range(3))# 通过标量创建
  
  s.index
  s.values
  s.name
  s2 = s1.rename('abc')
  

• 索引

  • 位置下标
  • 标签索引
  • 切片索引
  • 布尔型索引

  s[0] # 下标索引
  s[['a','c','b']]# 标签索引 生成新Series
  s[1:3]# [1:3)
  s['a':'c']#标签切片，[a:c]
  s[s>3]# 布尔型索引
  

• 基本技巧

  s.head(3)
  s.tail()
  
  # reindex不更改，只是选取index
  # 之前没有的index会返回NaN，这里填充
  s.reindex([5,2,3,'aa'],fill_value=0)
  
  # 对齐
  s1 +s2 # 其值按索引一一对应相加
  
  # 删除
  s.drop('子index')
  s.drop(['a','b'],inplace=True)# 按标签删除
  
  # 添加
  s['a']=100# 新标签index赋值，来添加
  s1.append(s2)# 添加一个数组
  

3 DataFrame

• 创建

  df = pd.DataFrame(data=None, 
               index=None,
               columns=None,
               dtype=None,
               copy=False)
  
  # 1 字典创建
  a={'aa':['bb']}
  pd.DataFrame(a)
  
  # 2 序列、数组
  b={'bb':np.random.rand(3),
     'bbb':np.random.rand(3)} 
  pd.DataFrame(b) # values为序列、数组创建——两列元素必须相等
  
  # 3 Series
  c={'cc':pd.Series(np.random.rand(3)),
    'ccc':pd.Series(np.random.rand(4))} 
  pd.DataFrame(c) # values为Series创建时——两个Series元素数量可以不相等
  
  # 4 二维数组
  pd.DataFrame(np.random.rand(9).reshape(3,3))
  
  
  # 5 字典组成的——列表创建
  data=[{'a':1,'b':2},{'a':2,'b':3,'c':33}]
  pd.DataFrame(data)# 列表中两个字典值数量可以不一
  
  # 6 字典组成的字典创建
  data={'a':{'aa':1,'bb':2,'cc':3},
       'b':{'aa':2,'bb':2,'cc':3},
       'c':{'aa':3,'cc':33}}
  pd.DataFrame(data,columns=['a','c','b'])# columns为字典的key
  pd.DataFrame(data,index=['aa','A','bb'])# index为 子字典 的key，指定新标签，返回值为NaN
  
  

• 索引

  df['col'] # 返回Series
  df[['col']]# 返回DataFrame
  df[['col1','col2']]
  df[df>0][['col1','col2']]
  df.loc[:,'col1':'col3']
  df.loc[['index3','index2'],'col1']
  df['col1'].loc[['index1','index2']]
  df.iloc[:3,:3]
  df[['col1','col2','col3']].iloc[:2]
  df[df>0].loc[['index1','index3']]
  df.query('col1 > 0')
  
  # 通过索引赋值
  

• 基本操作

  df.index
  df.columns
  df.values
  df.dtypes
  df.T
  
  # 添加列
  df['newcol']=
  df[['new_1','new_2']]=
  
  # 删除
  del df['col'] # 删除列
  df.drop(['ind1','ind2'],axis=0,inplace=True)# 删除行
  df.drop(['col1','col2'],axis=1,inplace=False)#删除列
  
  
  # 对齐
  df1 + df2 # 元素按(index,columns)意义对应相加
  
  # 排序
  df.sort_values(['col1'],ascending=False)# 降序
  df.sort_values(['col1','col2'],ascending=True)# 升序
  

4 数值计算、统计基础

• 常用数学、统计方法

  df['col'].dtype
  df.dtypes
  df.info()
  df.describe()
  df.quantile(q=0.75) # 统计分位数
  df.mean(axis=1,skipna=True)# 每行的均值，过滤掉空置
  df.sum()
  df.median() # 中位数
  df.count() # 统计非NaN值的数量
  df.min()
  df.std() # 标准差
  df.var() #　方差
  df.skew() # 偏度
  df.kurt() # 峰度
  
  # 累计
  df['col'].cumsum() # 累计和
  df['col'].cumprod() # 累计积
  df.cummax() # 累计最大值
  df.cummin() # 累计最小值
  
  # 唯一值
  s.unique().sort() # 去重、排序
  
  # 值计数
  s.value_counts(sort=False) # 计算出不同值出现的频率 ，sort：是否排序
  s.value_counts(normalize=True) # 频率是否转换为百分比
  pd.value_counts(s,sort=False)
  
  # 成员资格
  s.isin([3,2]) # 返回布尔值的Series
  df.isin(['a','bc'8]) # 返回布尔值的DataFrame
  s.isin(['a']) # 一定要加 []:s中是否包含a
  

5 文本数据-.str.

• 通过.str.调用字符串

  • 自动过滤NaN

  df['col'].str.upper() # 大写
  df.columns.str.upper() # 大写
  df['col'].str.lower() # 小写
  df['col'].str.len() # len字符长度
  df['col'].str.count('b') # 单列，每格中字符串，包含字符b 的个数
  df['col'].str.startswith('b') # 判断每格字符的 起始是否为b
  df['col'].str.endwith('a') # 判断结束是否为a
  
  # 替换
  df['col'].str.replace('替换谁','替换为',n=1) # n:替换个数
  df['col'].str.replace(['替换1','替换2','替换为'])
  df['col'].str.replace({'替换1':'替换为','替换2':'替换为2'})
  
  # 拆分
  df['col'].str.split('拆分符',expand=True) # 拆分后，返回DataFrame
  s.str.split(',',expand=True,n=1)# n:拆分几刀
  s.str.split(',').str.get(1) # 拆分后选第2列
  s.str.split(',').str[0] # 拆分后选择第一列
  # 从字符串末尾拆分
  s.str.rsplit(',')# 从右到左，拆分
  
  # 去除每格前后的空格，无法去重中间空格
  df['col'].str.strip() # 去除字符串中空格
  df['col'].str.lstrip() # 去除字符串中左空格
  df['col'].str.rstrip() # 去除字符串中右空格
  
  # 字符串索引
  s.str[1:-1] # 去除收尾字符
  s.str[:2] # 取前两个字符
  s.str[0]# 取第一个字符
  

6 合并

• pd.merge合并

  • SQL的join方式

  pd.merge(df1,df2,on='col')
  pd.merge(df1,df2,on=['col1','col3']) # 多键连接
  pd.merge(df1,df2,right_on='rcol1',lefg_on='lcol1')
  pd.merge(df1,df2,on=['rcol1','lcol1'],how='inner')# how：合并方式
  
  # 两个df的index作键
  pd.merge(df1,df2,left_on='key',right_index=True)
  pd.merge(df1,df2,left_index=True,right_on='2col')# 第一个df的index和第二个col作键
  pd.merge(df1,df2,left_index=True,right_index=True) # 以2个df的index作键
  pd.merge(df1,df2,on='key',sort=True,how='outer')# 排序，但会大大影响性能
  

  • sort=False
    • 是否排序
    • False，可大大提高性能
  • how=inner
    • 合并方式
    • inner,outer,left,right
  • suffixes=('_x', '_y')：默认
    • 合并后，之前同名的列添加后缀
    • suffixes=('_1', '_2')

• join合并

  • 通过index合并

  df1.join(df2,how='outer')
  df1,join(df2['col3'])
  

7 连接

• pd.concat

  pd.concat([s1,s2])# 上下堆叠
  pd.concat([s1,s2],axis=1) # 左右拼接 ，按index
  pd.concat([s1,s2],join='inner')# ｛'inner':'交集','outer':'联合'｝
  pd.concat([s1,s2],join_axes(['index1','index2','index3'])) # 指定联合的index
  pd.concat([s1,s2],keys=['one','two'])# 上下堆叠，keys为外层index
  Pd.concat([s1,s2],keys=['a','b'],axis=1)# 左右拼接，keys覆盖其列名
  
  pd.concat([df1,df2])# 上下堆叠，新增col，index的空值为NaN	
  

• combine_first

  • 修补
    • 按index，df1的NaN被df2填充
    • 如果df2的index多余df1，则更新到df1上

  df1.combine_first(df2)
  

• update

  • 覆盖
    • 按index
    • 相同index的，df2覆盖df1

  df1.update(df2)
  

• .map

  • 字典数据，与DataFrame关联

  df['new_col'] = df['字典共有col'].map(dict_data变量)
  

8 去重

• duplicated

  s.unique()
  s.duplicated() # 返回布尔序列
  s.drop_duplicates()# 移除重复值
  

---

9 分组统计

• 功能

  • 根据某些条件将数据拆分成组
  • 对每组独立应用函数
  • 将结果合并到一个数据结构中

  df.groupby(by=['col1','col3'],
             axis=0,# 默认行分组
             level=,
             as_index=True,
             sort=True,
             group_keys=True,
             squeeze=False
            ).mean() # 统计方法
  

• 分组——可迭代的对象

  for n, g in df.groupby('col1'):# n：组名， g：分组后的DataFrame
      print(n,g)
      
  list(df.groupby('col1'))
  

• 操作

  df.groupby('col1').groups # 返回字典{'组名'：'DataFrame'}——查看分组后的结构
  
  df.groupby('col1').get_group('组名1') # 返回一个组的DataFrame
  df.groupby('col1').groups['组名2']# 返回组的DataFrame——字典的索引
  
  df.groupby('col1').size()# 查看分组后的长度，每组元素数
  

• 按照数据类型分组

  for n, p in df.groupby(df.dtypes,axis=1): # axis=1，列分组
      print(n,p)
  

• 通过字典或Series分组

  dic={'col1','one','col2','one','col3':'two','col4':'two'}
  df.groupby(dic,axis=1)
  # col1、col2列分组到one，col3、col4列分组到two
  

• 通过函数分组

  df.groupby(lambda x:x.split('')[0])#对字符串型索引分组
  df.groupby(df['timecol'].dt.week)#Datetime64[ns]类型列
  df.groupby(len).sum()# 按index字符长度分组
  

分组计算

• 函数方法

  df.groupby(level=0)#唯一索引用，将统一index分为一组
  
  grouped=df.groupby('')
  grouped.first()#非NaN的第一个值
  grouped.last() # 非NaN的最后一个值
  grouped.sum() # 和
  grouped.mean() # 均值
  grouped.median() # 中位数
  grouped.std()# 标准差
  grouped.var()# 方差
  grouped.prod()# 非NaN的积
  

• 多函数计算

  df.groupby('col').agg(['mean',np.sum])# 分组后分别将isuan均值、求和
  df.groupby('col')['col3'].agg({'result1':np.mean,
                                'result2':np.sum})#和上面一样，但可自定义列名，而不是自带的mean和sum
  

分组转换

• transform

  • 字符串不能进行计算
  • 返回的结构，与df中可计算的每个元素位置一一对应

  df.groupby('col1').mean()
  
  df.groupby('col1').transform(np.mean)#与上面比，其结构与df的结构一致
  

• apply

  • apply直接运行其中的函数

  df.groupby('col1').apply(lambda x:x.describe())
  
  # 返回排序后的前n行
  def f_df1(d,n):
      return(d.sort_index()[:n])
  # 返回分组后的'k1'列
  def f_df2(d,k1):
      return(d[k1])
  df.groupby('col1').apply(f_df1,n=2)
  df.groupby('col1').applyt(f_df2,'col2')
  

• df.groupby(['col1','col2']).size().unstack().plot.barh(stacked=True,color=['r','k'])
  f.groupby(['unique_carrier','delayed']).size().unstack().plot.barh(stacked=True,color=['red','k'])
  

10 透视表

• pd.pivot_table()

• 交叉表

  pd.crosstab()
  

11 数据读取

• pd.read_table

  • 读取csv、txt

  pd.read_table('demo.txt',delimiter=',', # 指定分隔符，也可用sep=','
               header=0, # 第一行用作columns
               index_col=1) # 指定第2列为索引
  

• pd.read_csv

  • 多数情况先将EXCEL导出为csv读取

  pd.read_csv('demo.csv',
              engine='python', # 解析方式
              encoding='gbk', # 指定字符集类型，即编码
             )
  

  • engine='python'
    • 解析方式
    • 分析引擎
    • 可选C或python
      • C：引擎快
      • python引擎：功能完备

• pd.read_excel

  pd.read_excel('demo.xlsx',
                sheetname='读取页的名称', # 返回多表使用sheetname=[0,1],若sheetname=None则返回全表
                header=0,
                index_col=1 # 读取为索引，
               )
  

  • sheetname=
    • None
      • 读取全表
      • 返回字典
    • [0,1]
      • 读取多表
      • 返回字典
    • ‘表名1’
      • 返回DataFrame
      • 读取表名为’表名1’的表
    • 1
      • 返回DataFrame
      • 读取第2张表

12 虚拟变量

pd.get_dummies(df['col']) # 创建虚拟变量

pd.concat([df,pd.get_dummies(df['col'])],axis=1) # 合并

时间模块

• 时间转字符串

  • datetime.now().strftime('%Y-%m-%d')

• 字符串转时间

  • datetime.strptime('2017/4/12','%Y/%m/%d')

• datetime转UNIX timestamp(UNIXtimestamp：从1970/1/1起，到现在，过了多少秒)

  • from time import mktime
    mktime(datetime.now().timetuple())
    

• UNIX timestamp转datetime

  • datetime.fromtimestamp(1492859823)
    

• 区分：

  • datetime.datetime：Datetime模块的数据类型
  • Timestamp：pandas的时间数据类型
    • 单个时间点
  • DatetimeIndex：pandas的时间数据类型
    • 多个时间点
  • TimeSeries：时间序列
    • 索引为DatetimeIndex的Series

• datetime库

  import datetime
  datetime.date.today()
  datetime.date(2019,2,12)
  
  datetime.datetime.now()
  t1 = datetime.datetime(2019,2,1)
  t2 = datetime.datetime(2019,2,12,11,22,33)
  
  t2 - t1 # 时间差，timedelta
  t1 - datetime.timedelta(1) 
  

• parser.parse 日期字符串转换

  from dateutil.parser import parse
  
  date='12-30-2018'
  
  # 将str转换为datetime.datetime 
  parse(date) 
  parse('5/1/2019',dayfirst=True) # 国际通用格式中，日在月之前，可以通过dayfirst来设置
  parse('Jan 31, 1997 10:45 PM') # 解析各种格式的日期，不支持中文
  

pd.Timestamp()

• 时间戳-pandas的时间数据结构——Timestamp:单个时间点

  # 数据类型pandas的Timestamp
  pd.Timestamp('2019-1-20 13:00:22')
  

pd.to_datetime()

# 单个时间数据，转换为pandas的时间戳Timestamp
pd.to_datetime(datetime.datetime(2019,1,22))
pd.to_datetime('2018/11/11')

# 多个时间数据，转换为DatetimeIndex
pd.to_datetime(['2018/11/11','2017/11/11','2016/11/11'])
pd.to_datetime([datetime.datetime(2019,1,22),datetime.datetime(2019,1,23)])

# 当数据中包含其他格式数据是
pd.to_datetime(['2018/11/11','ABC','2016/11/11'],errors='ignore')

• errors='ignore'
  • 不可解析时，返回原始输入
• errors='coerce'
  • 不可解析时，该元素返回为NaT（Not a Time）

时间戳索引

pd.DatetimeIndex

• DatetimeIndex：多个时间点

• pd.DatetimeIndex()

  • 支持
    • str
    • datetime.datetime
  • 以DatetimeIndex为index的Series为——时间序列

  # 解析多个为DatetimeIndex
  pd.DatetimeIndex(['2018/11/11','2017/11/11','2016/11/11'])
  
  # 解析单个为Timestamp
  pd.DatetimeIndex('2018/11/11')
  

pd.date_range()

• 生成DatetimeIndex

  # 默认 日历日频率
  pd.date_range('1/1/2017','1/1/2018',normalize=True,name='demo')
  pd.date_range('1/1/2017',periods=10)
  pd.date_range(end='1/1/2017 13:00:00',periods=10)
  
  pd.date_range('20170101','20180101',closed='right')#左开右闭
  pd.date_range('20170101','20180101',closed='left')#左闭右开
  pd.date_range('20170101','20180101')#左闭右闭
  
  
  
  # 默认 工作日频率
  pd.bdate_range('20190101','20191230')#工作日频率
  
  # 转换为list
  
  list( pd.date_range('20170101','20180101',closed='right') )
  

  • normalize=
    • 时间参数值正则化到午夜时间戳
  • name=
    • 索引对象名称
  • tz=
    • 时区

• freq

  freq=’’	解释
  H	每小时
  B	每工作日
  D	每日历日
  T	每分
  MIN	每分
  S	每秒
  L	每毫秒-千分之一秒
  U	每微秒-百万分之一秒
  W-MON	每周——从每月第一个星期一开始算起
  星期缩写	MON/TUE/WED/THU/FRI/SAT/SUN
  W-2MON	每2周——每月的第2个星期一开始算
  M	每月最后一个日历日
  Q-月	指定月为季度末，每个季度末最后一月的最后一个日历日
  A-月	每年指定月份的最后一个日历日
  月缩写	JAN/FEB/MAR/APR/MAY/JUN/JUL/AUG/SEP/OCT/NOV/DEC
  BM	每月最后一个工作日
  BQ-月	指定月为季度末，每个季度末最后一月的最后一个工作日
  BA-月	每年指定月份的最后一个工作日

• 符合频率

  freq=''
  7D
  2h30min
  2M

• 时间频率转换——asfreq

  df.asfreq('4H',method='ffill')# 频率改为4H
  

  • method=
    • 插值模式

.shift()

1. 对数值进行位移——超前/滞后数据

df.shift(2)# 正数： 数值后移（滞后）
df.shift(-2)# 复数： 数值前移（超前）

• 百分比

df['newcol'] = df['col1'] / df.shift(1)['col1'] -1 # 元素与 前一天比较
df.style.format('{.2%}',subset='newcol')# 转换为百分数

2. 对时间戳进行位移

df.shift(2,freq='D') # 对时间戳进行位移 
df.shift(2,freq='T') #

pd.Period()

• 创建时期_时间段

  p = pd.Period('2019',freq='M') # 生成一个月为频率的时间构造器，2019-01
  
  p+1 # 2019-02
  p-1 # 2018-12
  
  # 频率转换
  p = pd.Period('2019','A-DEC')
  p.asfreq('M',how='start') # 转换成别的频率，2019-01
  p.asfreq('D',how='end') # 2018-12-31
  

pd.period_range()

• 创建时期范围

  pd.period_range('2019/1/1','2020/1/1',freq='M')
  

• 频率转换

  p=pd.Period_range('2018','2019',freq='M')
  p.asfreq('D',how='start') # 由月，变为当月的第一天（start），end是当月最后一天
  

时间	解释
pd.Timestamp()	时间戳 单个时间点
pd.to_datetime()	多个时间点
pd.DatetimeIndex()	多个时——多个时间点、时间戳
pd.date_range()	生成DatetimeIndex
pd.bdate_range()	生成DatetimeIndex 非工作日
df.shift(2)	超前、滞后——值
s.shift(2,freq='D')	超前、滞后——索引
pd.Period(‘2019’,freq='M')	时间段 pandas的Period
pd.period_range()	PeriodIndex数据类型 创建时期范围
s1.to_timestamp()	每月，转化为当月第一天
s1.to_period()	每月最后一天，转化为每月

星期几、第几周

df['dayofweek']=pd.to_datetime(df['time']).dt.dayofweek
df['week']=pd.to_datetime(df['time']).dt.week

索引、切片

• 索引

  • 适用于DataFrame
  • rng = pd.date_range('2018/1','2019/1')
  • ts=pd.Series(np.random.rand(len(rng)),index=rng)

  # 索引
  ts.loc['20180101']
  ts['20190101']
  ts['1/1/2019']
  ts[datetime.datetime(2018,2,1)]
  
  # 切片
  ts[::2] # 下标切片
  ts['2018/02']# 传入月，直接切片
  ts['1/2019']
  ts['2019-1'][::2]
  ts['2018/01/01':'2018/12/12']
  ts.loc['2018/01/01':'2018/12/12']
  

• 重复的index

  ts.index.is_unique #判断index是否有重复值
  ts['2018/12/23']# index不唯一时，返回多个值
  ts.groupby(level=0).mean()# 对重复index分组
  

采样resample()

• 重采样——从一个频率，转为另一个频率，且有数据的聚合

  • 降采样：高频数据–> 低频数据
  • 升采样：低频数据–> 高频数据

  ts.resample('5D').sum() #重采样
  
  # 降采样
  ts.resample('M',closed='left',label='left').mean()
  

  • closed=参数
    • 默认为None，左闭右闭——把时间区间分割
    • left：左闭右开
    • right：左开右闭
  • label=参数
    • 聚合值的index
    • 默认取 left：采样每组的第一个值的index作为，聚合值的index
    • right：采样每组的最后一个值的index作为，聚合值的index

• 升采样

  ts.resample('T').asfreq() # 不做填充，返回NaN
  ts.resample('T').ffill() # 向上填充
  ts.resample('T').bfill() # 向下填充
  

• 时期period的采样

  prng=pd.period_range('2018','2019',freq='M')
  pts = pd.Series(np.arange(len(prng)),index=prng)
  
  pts.resample('3M').sum() # 降采样
  pts.resample('15D').ffill() #　升采样
  

• 聚合方法
  ts.resample('3D').mean()
  ts.resample('3D').max()
  ts.resample('3D').min()
  ts.resample('3D').median()
  ts.resample('3D').first()	返回第一个值
  ts.resample('3D').last()	返回最后一个值
  ts.resample('3D').ohlc()	OHLC重采样 金融领域的时间序列聚合方式
  OHLC返回多列：Open开盘，High最大值，Low最小值，close收盘

matplotlib

seaborn