序列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上的行和列

扫描二维码关注公众号，回复： 5963770 查看本文章

函数和自定义函数

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=
  - 插值模式

`freq=''`
7D
2h30min
2M

`.shift()`

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

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

百分比

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

对时间戳进行位移

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收盘

【2019】python3基础

文章目录

基础

1. 变量类型

字符串

%格式化字符串