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

`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基礎

文章目錄

基礎