四虎家庭影院,亚洲丁香婷婷久久一区二区,又大又粗欧美黑人aaaaa片

本文章僅供我本人學習記錄使用，不允許任何轉載及引用。特此聲明。

Pandas是建立在Numpy的基礎上的，處理二維數據時更加得心應手。
Pandas增加了更多高級使用的功能，比如數據自動對齊功能，時間序列的支持，確實數據的靈活處理等等。

In[1]: import pandas as pd
In[2]: import bumpy as np
In[3]: from pandas import Series, DataFrame

Series 和 DataFrame

是Pandas的兩種核心數據結構。

Series:

Series是值的序列，可以理解為一維數組，它只有一個列和索引。
索引可以定制，當不指定時默認使用整數索引，而且索引可以被命名：

In[1]:s1 = Series([1, 2, 3, 4, 5]) 
Out[1]: 
0    1
1    2
2    3
3    4
4    5
dtype: int64
# 第一列是未指定時默認的整數索引

In[2]: s2 = Series([1, 2, 3, 4, 5], index = ['a', 'b', 'c', 'd', 'e'])
Out[2]: 
a    1
b    2
c    3
d    4
e    5
dtype: int64
# 定制索引時

In[3]: s2.index.name = 'index'

In[4]: s2.index
Out[4]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object', name='index')

In[5]: s2
Out[5]:
index
a    1
b    2
c    3
d    4
e    5
dtype: int64

DataFrame:

DataFrame類似于二維數組，有行和列之分，除了像Series一樣，多個行有索引之外，每個列上面還可以有標簽label，索引和標簽本身都可以被命名：

In[1]: df = DataFrame(np.random.randn(4, 4), index = ['a', 'b', 'c', 'd'], columns = ['A', 'B', 'C', 'D'])
Out[1]: 
          A         B         C         D
a -0.877290  0.434619 -0.996634 -0.398794
b  1.131611 -1.553991 -0.696632 -0.209264
c  0.785401 -0.967436 -0.063710 -0.442142
d  0.045040 -0.446373  1.835974  0.820756
# index和columns的設置也可以用index = list('abc')

In[2]: df.index
Out[2]: Index(['a', 'b', 'c', 'd'], dtype='object')

In[3]: df.index.name = 'Index1'
Out[3]: Index(['a', 'b', 'c', 'd'], dtype='object', name='Index1')

In [4]: df.columns
Out[4]: Index(['A', 'B', 'C', 'D'], dtype='object')

In[5]: df.columns.name = 'Col'
Out[5]: Index(['A', 'B', 'C', 'D'], dtype='object', name='Col')

In[6]: df
Out[6]: 
Col            A         B         C         D
Index1
a      -0.877290  0.434619 -0.996634 -0.398794
b       1.131611 -1.553991 -0.696632 -0.209264
c       0.785401 -0.967436 -0.063710 -0.442142
d       0.045040 -0.446373  1.835974  0.820756

# ***行列轉換***
In[]: df.T

選擇

當需要選擇部分數據時:

Series:

主要通過其索引來進行選擇：

In[1]: s2 = Series([1, 2, 3, 4, 5], index = ['a', 'b', 'c', 'd', 'e'])
Out[1]: 
a    1
b    2
c    3
d    4
e    5
dtype: int64

In[2]: s2[0]
Out[2]: 1
# 默認整數索引，一直存在的

In[3]: s2['a']
Out[3]: 1
# 指定后的索引

In[4]: s2[0:3]
Out[4]: 
a    1
b    2
c    3
dtype: int64

In[5]: s2['a':'c']
Out[5]: 
a    1
b    2
c    3
dtype: int64

以上調用多行，使用了s2.N和s2.loc。

s2[0:3]相當于s2.iloc[0:3]，
s2['a':'c']相當于s2.loc['a':'c']，
不能互換
如下：

In[6]: s2.iloc[0:3]
Out[6]: 
a    1
b    2
c    3
dtype: int64

In[7]: s2.loc['a':'c']
Out[7]: 
a    1
b    2
c    3
dtype: int64

通過步長，用 iloc [[[間隔調用多行]]]:

In []: s2.iloc[::2]
Out[]:
a    1
c    3
e    5
dtype: int64

方法一：iloc[::5]

方法二：index.isin()

.iloc和.loc和.ix的區別進階學習：
.ix：(https://fishc.com.cn/thread-79821-1-1.html)
區別：（https://blog.csdn.net/hecongqing/article/details/61927615）

DataFrame:

由于有行列之分，所以可以有多種選擇數據的方式：
-- 通過索引或標簽來選擇：

(1) 用標簽（列）選擇：

In[8]: df
Out[8]: 
          A         B         C         D
a -1.219787  0.730984 -0.785763 -0.634453
b -0.317280 -1.279367  0.359007  0.700775
c -2.226339  0.380315  2.120930 -1.161018
d -1.212816 -0.777530 -0.130212  1.492688

In[9]: df.A
Out[9]: 
a   -1.219787
b   -0.317280
c   -2.226339
d   -1.212816
Name: A, dtype: float64

In[10]: df['A']
Out[10]: 
a   -1.219787
b   -0.317280
c   -2.226339
d   -1.212816
Name: A, dtype: float64
# 使用標簽，df.A和df['A']相同，可以選擇某1列

# 使用標簽，選擇多列：
In[11]: df[df.columns[0:2]]
Out[11]: 
          A         B
a -1.219787  0.730984
b -0.317280 -1.279367
c -2.226339  0.380315
d -1.212816 -0.777530
# 只能使用默認整數索引
# 或者df.loc[:, ['A':'B']]，下面有演示

---查看列名：

In[]: df.columns.tolist()
Out[]:

---刪除列或刪除行：

In[]: 
df.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')    
# 例：
In[]: 
df.drop((0, 'b_amt'), axis=1)
# (0, 'b_amt')就是一個列名，不用加‘’或()或[]

# 或 
In[]:
df.drop(['B', 'C'], axis=1)
# 或 
In[]: 
df.drop(index='cow', columns='small')
# Drop a row by index:
In[]: 
df.drop([0, 1])

---重命名列columns：

In[]:
df.rename(columns={'A':'a', 'B':'b'})

(2).選擇‘行’：

使用loc和iloc選擇一行或多行


In[12]: df
Out[12]: 
          A         B         C         D
a -1.219787  0.730984 -0.785763 -0.634453
b -0.317280 -1.279367  0.359007  0.700775
c -2.226339  0.380315  2.120930 -1.161018
d -1.212816 -0.777530 -0.130212  1.492688

In[13]: df.loc['a']
Out[13]: 
A   -1.219787
B    0.730984
C   -0.785763
D   -0.634453
Name: a, dtype: float64
# df.iloc[0]有同樣效果

In[14]: df.loc['a':'b']
Out[14]: 
          A         B         C         D
a -1.219787  0.730984 -0.785763 -0.634453
b -0.317280 -1.279367  0.359007  0.700775

# 用loc和iloc選擇列：
In[15]: df.loc[:, 'A':'B']
Out[15]: 
          A         B
a -1.219787  0.730984
b -0.317280 -1.279367
c -2.226339  0.380315
d -1.212816 -0.777530
# 相當于用‘：’同時選擇所有行，并在所有列中選擇某幾列。

# 由此知道，選擇某一行某一列的一個元素，或某幾行或某幾列的多個元素就簡單了：
In[16]: df
Out[16]: 
          A         B         C         D
a -1.219787  0.730984 -0.785763 -0.634453
b -0.317280 -1.279367  0.359007  0.700775
c -2.226339  0.380315  2.120930 -1.161018
d -1.212816 -0.777530 -0.130212  1.492688

In[17]: df.loc['a', 'A']
Out[17]: -1.2197869779119481
# df.iloc[0, 0]，效果相同

In[18]: df.loc['b':'c', 'C':'D']
Out[18]: 
          C         D
b  0.359007  0.700775
c  2.120930 -1.161018
# df.iloc[1:3, 2:4]， 效果相同

# ***隔列選擇***
df[['A','D']]  
#選擇表格中的'w'、'z'列
#更多請查看：https://blog.csdn.net/wanglingli95/article/details/78887771

缺失值'NaN'和數據自動對齊

在Pandas中最重要的一個功能是，它可以對不同索引的對象進行算術運算。比如將兩個Series數據進行相加時，如果存在不同的索引，則結果是兩個索引的并集，示例如下：

In[1]: s1 = Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])

In[2]: s1
Out[2]: 
a    1
b    2
c    3
d    4
dtype: int64

In[3]: s2 = Series([2, 3, 4, 5], index = ['b', 'c', 'd', 'e'])
Out[3]: 
b    2
c    3
d    4
e    5
dtype: int64

In[4]: s1 + s2
Out[4]: 
a    NaN
b    4.0
c    6.0
d    8.0
e    NaN
dtype: float64
# 兩個索引的并集

2個Series中['b', 'c', 'd']的索引是相同的，所以值可以相加，但不重疊的索引引入了NaN值（缺失值）。
而缺失值會在運算中傳播，所以最終結果也是NaN值。（后面會講解）
根據相同的索引進行自動計算，這就是自動對齊功能。

在DataFrame中，相同的規格也生效：

In[5]: df1 = DataFrame(np.arange(9).reshape(3, 3), columns = list('ABC'), index = list('abc'))
Out[5]: 
   A  B  C
a  0  1  2
b  3  4  5
c  6  7  8

In[6]: df2 = DataFrame(np.arange(12).reshape(3,
    ...: 4), index = list('bcd'), columns = list('
    ...: ABDE'))
Out[6]: 
   A  B   D   E
b  0  1   2   3
c  4  5   6   7
d  8  9  10  11

In[7]: df1 + df2
Out[7]: 
      A     B   C   D   E
a   NaN   NaN NaN NaN NaN
b   3.0   5.0 NaN NaN NaN
c  10.0  12.0 NaN NaN NaN
d   NaN   NaN NaN NaN NaN

可以看出，DataFrame的計算也進行了自動對齊操作，NaN值被自動填充，而由于NaN值會傳播（如上解釋），所以相加的結果也是NaN。
如果我們想避免結果為NaN值，可以指定使用值來填充（替代）NaN值，如下：

In[8]: df1.add(df2, fill_value = 0)
Out[8]: 
      A     B    C     D     E
a   0.0   1.0  2.0   NaN   NaN
b   3.0   5.0  5.0   2.0   3.0 
c  10.0  12.0  8.0   6.0   7.0
d   8.0   9.0  NaN  10.0  11.0
# 使用fill_value參數指定NaN值的填充值，使用與Series和DataFrame。

我們指定了‘0’填充了NaN值，然后帶入計算過程（這里是先填充值，再運算）。
這里剩余的NaN值是因為df1和df2中都未定義。

常用運算

Series和DataFrame的常用運算和Numpy差不多。
在Pandas中還有一種比較常見的操作時將函數運用到每一行或者每一列上面，DataFrame的apply方法可以實現此功能，比如想統計每行和每列的極差（最大值和最小值之差）：

In[1]: df1 = DataFrame(np.arange(9).reshape(3, 3
    ...: ), index = list('abc'), columns = list('A
    ...: BC'))

In[2]: df1
Out[2]: 
   A  B  C
a  0  1  2
b  3  4  5
c  6  7  8

In[3]: f = lambda x: x.max() - x.min()
# 定義了f，f是匿名函數

In [4]: f
Out[4]: <function __main__.<lambda>>
# f匿名函數簡單的返回列表的極差

In[5]: df1.apply(f)
Out[5]: 
A    6
B    6
C    6
dtype: int64
# 將計算極差的匿名函數f使用apply方法應用到df1上

In [6]: df1.apply(f, axis = 1)
Out[6]:
a    2
b    2
c    2
dtype: int64
# 這個加入了參數axis = 1，所以計算df1中每一行的極差（索引‘a’行中max最大值‘2’和min最小值‘0’之差是2）
# 上一個計算中，默認的axis是0（列），所以計算的是每一列的極差（索引‘A’列中max最大值‘6’和min最小值‘0’之差是6）

如果想將某函數應用到每一個元素上，DataFrame可以使用df.applymap方法，Series可以使用s.map方法：

In [7]: df1.applymap(lambda x: x + 1)
Out[7]:
   A  B  C
a  1  2  3
b  4  5  6
c  7  8  9

In [8]: s1
Out[8]:
a    1
b    2
c    3
d    4
dtype: int64

In [9]: s1.map(lambda x: x + 1)
Out[9]:
a    2
b    3
c    4
d    5
dtype: int64
# 以上結果是讓所有元素增加1，其結果與df1 + 1和s1 + 1的運算結果相同。

常用統計：

比如求平均值，方差等，同時通過describe方法可以得知當前數據的一些常用統計信息：

In[]: df1 = DataFrame(np.arange(9).reshape(3,3), columns=list('ABC'), index=list('abc'))

In[]: df1
Out[]: 
   A  B  C
a  0  1  2
b  3  4  5
c  6  7  8

In[]: df1.sum()
Out[]: 
A     9
B    12
C    15
dtype: int64
# 每列求和

In[]: df1.sum(axis = 1)
Out[]:
a     3
b    12
c    21
dtype: int64
# 每行求和

In[]: df1.mean()
Out[]:
A    3.0
B    4.0
C    5.0
dtype: float64
# 每列的平均數

In []: df1.mean(axis = 1)
Out[]:
a    1.0
b    4.0
c    7.0
dtype: float64
# 每行的平均數

In[]: df1.describe()
Out[]: 
         A    B    C
count  3.0  3.0  3.0 # 列的元素的數量
mean   3.0  4.0  5.0 # 列的平均值
std    3.0  3.0  3.0 # 列的標準差
min    0.0  1.0  2.0 # 列的最小值(0%)
25%    1.5  2.5  3.5 # 下四分位數
50%    3.0  4.0  5.0 # 中位數
75%    4.5  5.5  6.5 # 上四分位數
max    6.0  7.0  8.0 # 列的最大值(100%)

In[]: df1.loc['b'].describe()
Out[]:
count    3.0
mean     4.0
std      1.0
min      3.0
25%      3.5
50%      4.0
75%      4.5
max      5.0
Name: b, dtype: float64
# 第二行'b'行的統計信息
# *目前還不知道怎么統計多行信息*

數據合并和分組

合并2個DataFrame數據，方法主要有2種：
（1）簡單進行拼接，通過pd.concat方法實現
（2）根據列名類像數據庫表查詢一樣進行合并，通過pd.merge方法實現

In[]: df1 = DataFrame(np.random.randn(3, 3))

In[]: df2 = DataFrame(np.random.randn(3, 3), index = [5, 6, 7])

In[]: df1
Out[]: 
          0         1         2
0 -2.072551 -1.759958  0.465906
1 -1.302374  2.343270  0.233606
2 -1.450751  1.160754  1.271709

In[]: df2
Out[]: 
          0         1         2
5  0.092593  1.846336  1.757417
6  0.328430 -1.662719 -0.366255
7 -0.360098 -0.334050 -0.032662

In[]: pd.concat([df1, df2])
Out[]: 
          0         1         2
0 -2.072551 -1.759958  0.465906
1 -1.302374  2.343270  0.233606
2 -1.450751  1.160754  1.271709
5  0.092593  1.846336  1.757417
6  0.328430 -1.662719 -0.366255
7 -0.360098 -0.334050 -0.032662
# 當多個數據集，擁有相同的列時，我們可以按照這個列進行合并操作
# 類似于數據庫中的join操作

In[]: df3 = DataFrame({'code':[600276, 600519], 'name':['hengrui', 'maotai'], 'bought_price': [0.00, 649.00]})

In[]: df3
Out[]: 
   bought_price    code     name
0           0.0  600276  hengrui
1         649.0  600519   maotai

In[]: df3 = df3.rename(columns = {'bought_price':'in
     ...: _price'})
Out[]:
   in_price    code     name
0       0.0  600276  hengrui
1     649.0  600519   maotai
# 重命名單個或多個列索引

In[]: df4 = DataFrame({'code': [600276, 600519], 'volume': [100, 100], 'in_date': ['2019-03-18', '2018-02-13']})

In[]: df4
Out[]: 
     code     in_date  volume
0  600276  2019-03-18     100
1  600519  2018-02-13     100

In[]: pd.merge(df3, df4)
Out[]: 
   in_price    code     name     in_date  volume
0       0.0  600276  hengrui  2019-03-18     100
1     649.0  600519   maotai  2018-02-13     100

自我理解：

pd.concat([])用于合并行：當行內容不同時，列名相同
pd.merge()用于合并列：當列內容不同時，行名相同

上面的代碼中我們通過字典創建了兩個數據集，可以看到當通過字段創建DataFrame數據集時，鍵名key變成了列名column name。
df3和df4有共同的列course，當進行merge操作的時候Pandas會自動將這列進行合并。
合并數據集時，有很多參數可以選擇，比如選擇在根據哪一列進行合并、合并的方式等，可以用help(pd.merge)查看完整的幫助文檔。

在Pandas中，也支持類似于數據庫查詢語句GROUP BY的功能，也就是按照某列進行分組，然后再分組上進行一些計算操作：

In[]: df  = DataFrame({'user_id': ['Jack', 'Sam', 'Jack'], 'course': ['Math', 'Sci', 'Eng'], 'minutes': [9, 36, 45]})

In[]: df
Out[]: 
  course  minutes user_id
0   Math        9    Jack
1    Sci       36     Sam
2    Eng       45    Jack

# 方法一：篩選出所有user_id為'Jack'的行，然后進行求和統計：
In[]: df[df['user_id'] == 'Jack']
Out[]: 
  course  minutes user_id
0   Math        9    Jack
2    Eng       45    Jack

In[]: df[df['user_id'] == 'Jack']['minutes']
Out[]: 
0     9
2    45
Name: minutes, dtype: int64

In[]: df[df['user_id'] == 'Jack']['minutes'].sum()
Out[]: 54
# 可以看出我們可以先通過df[df['user_id'] =='Jack']布爾索引篩選出所有的相關行，然后通過結合列篩選功能過濾其他列，只剩下時間統計列（minutes所在列為學習時間列），最后通過求和運算統計出了學習時間。

# 方法二：類似于數據庫的GROUP BY功能進行計算：
In[]: df[['user_id', 'minutes']]
Out[]: 
  user_id  minutes
0    Jack        9
1     Sam       36
2    Jack       45

In[]: df[['user_id', 'minutes']].groupby('user_id').sum()
Out[]: 
         minutes
user_id
Jack          54
Sam           36
# 可以看到，我們先過濾列，只剩下了user_id和minutes列，然后通過groupby方法在user_id列上進行分組并求和，相對于前一種方式，分組求和更靈活一些。

自我理解分解：

進行邏輯比較運算（Numpy和Pandas都可以），比如我們想知道一個多維數組中哪些值大于某一個指定值

通過一個元素查詢行數據

# 1.
In[]: df_bool = df['user_id'] == 'Jack'
# 計算'user_id'列是否等于'Jack', 用df_bool顯示
In[]: df_bool
Out[]: 
0     True
1    False
2     True
Name: user_id, dtype: bool

In []: df[df_bool]
Out[]:
  course  minutes user_id
0   Math        9    Jack
2    Eng       45    Jack
# 將a_bool放在df中比較，將只顯示a_bool中為'True'的'user_id列'所在的行內容。
# 等同于df[df[...]]

# 2.
In[]: df[df['user_id'] == 'Jack']['minutes']
Out[]: 
0     9
2    45
Name: minutes, dtype: int64

In[]: df[df['user_id'] == 'Jack'].minutes
Out[]: 
0     9
2    45
Name: minutes, dtype: int64
# ['minutes']和.minutes的輸出結果相同，都是對DataFrame的‘列選擇’操作

# 3. 上面篩選出來的是‘Name: minutes, dtype: int64’，所以.sum()是對minutes的元素值進行求和
In[]: df[df['user_id'] == 'Jack']['minutes'].sum()
Out[]: 54

時間序列處理

根據數據集中的時間戳進行運算，
在Python中，時間處理方面的相關功能主要集中在datetime包中，主要有三種對象：

datetime.datetime：代表時間對象；
datetime.date：代表某一天；
datetime.timedelta：代表兩個datetime.datetime對象之間的時間差。

# datetime.datetime和datetime.timedelta的用法
In[]: from date time import datetime, timedelta

In[]: d1 = datetime(2017, 8, 1)
Out[]: datetime.datetime(2017, 8, 1, 0, 0)

In[]: delta = timedelta(days=10)

In[]: d1 + delta
Out[]: datetime.datetime(2017, 8, 11, 0, 0)

In[]: dates = [datetime(2018, 1, 1), datetime(2018, 1, 2), datetime(2018, 1, 3), datetime(2018, 1, 4)]
Out[]: 
[datetime.datetime(2018, 1, 1, 0, 0),
 datetime.datetime(2018, 1, 2, 0, 0),
 datetime.datetime(2018, 1, 3, 0, 0),
 datetime.datetime(2018, 1, 4, 0, 0)]

In[]: ts = Series(np.random.randn(4), index = dates)
Out[]: 
2018-01-01    0.241635
2018-01-02    0.121023
2018-01-03   -1.992435
2018-01-04   -0.457257
dtype: float64

In[]: ts.index
Out[]: DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04'], dtype='datetime64[ns]', freq=None)

In[]: ts.index[0]
Out[]: Timestamp('2018-01-01 00:00:00')

# 通過datetime時間類型生成了一堆時間，然后基于此創建了一個時間序列ts， 可以看到ts的索引類型為DatetimeIndex類型。
生成ts以后我們就有多種方法選擇元素了，只需要傳入一個能被Pandas識別的日期字符串就可以了，如下：

In []: ts
Out[]:
2018-01-01    0.241635
2018-01-02    0.121023
2018-01-03   -1.992435
2018-01-04   -0.457257
dtype: float64

In []: ts.index[0]
Out[]: Timestamp('2018-01-01 00:00:00')

In []: ts[ts.index[0]]
Out[]: 0.2416345185713773

In [311]: ts['2018-01-01']
Out[311]: 0.2416345185713773

In [312]: ts['2018/01/01']
Out[312]: 0.2416345185713773

In [313]: ts['1/1/2018']
Out[313]: 0.2416345185713773

In[]: ts[datetime(2018, 1, 1)]
Out[315]: 0.2416345185713773
# ts[ts.index[0]] ， ts['2018-01-01']， ['2018-01-01']， ts['1/1/2018']， ts['1/1/2018'] 都可以選擇同一個元素

生成日期范圍：

在Pandas中生成日期范圍主要通過pandas.date_range函數完成，該函數主要有以下幾個參數：

start：指定了日期范圍的起始時間；
end：指定了日期范圍的結束時間；
periods：指定了間隔范圍，如果只是指定了start和end日期中的其中一個，則需要改參數；
freq：指定了日期頻率，比如D代表每天，H代表每小時，M代表月，這些頻率字符前也可以指定一個整數，代表具體多少天。。。，比如5D代表5天。還有一些其他的頻率字符串，比如MS代表每月第一天，BM代表每月最后一個工作日，或者是頻率組合字符串，比如1h30min代表1小時30分鐘。
如下：

In[]: pd.date_range('2018-1-1', '2019', freq = 'M')
Out[]: 
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
               '2018-05-31', '2018-06-30', '2018-07-31', '2018-08-31',
               '2018-09-30', '2018-10-31', '2018-11-30', '2018-12-31'],
              dtype='datetime64[ns]', freq='M')

In[]: pd.date_range('2018-01-01', '2019', freq = 'BM')
Out[]: 
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-30', '2018-04-30',
               '2018-05-31', '2018-06-29', '2018-07-31', '2018-08-31',
               '2018-09-28', '2018-10-31', '2018-11-30', '2018-12-31'],
              dtype='datetime64[ns]', freq='BM')

In[]: pd.date_range('2018-1-1', '2019', freq = 'MS')
Out[]: 
DatetimeIndex(['2018-01-01', '2018-02-01', '2018-03-01', '2018-04-01',
               '2018-05-01', '2018-06-01', '2018-07-01', '2018-08-01',
               '2018-09-01', '2018-10-01', '2018-11-01', '2018-12-01',
               '2019-01-01'],
              dtype='datetime64[ns]', freq='MS')
# 更多date_range()方法的使用請看Pandas datetime學習筆記

有的時候時間序列是按每小時顯示統計的，但是我們想將統計頻率轉換成按天來統計，這個時候可以使用時間序列的resample方法，該方法非常強大，不僅僅支持高頻率的數據聚合到低頻率（降采樣），也支持低頻率轉化到高頻率統計（升采樣）：

In[]: dates = pd.date_range('2018-1-1', '2018-1-2 23:00:00', freq = 'H')

In[]: len(dates)
Out[]: 48

In[]: ts = Series(np.arange(len(dates)), index = dates)

In[]: ts.size
Out[]: 48

In[]: ts.head(5)
Out[]:
2018-01-01 00:00:00    0
2018-01-01 01:00:00    1
2018-01-01 02:00:00    2
2018-01-01 03:00:00    3
2018-01-01 04:00:00    4
Freq: H, dtype: int64


In[]: ts.tail(5)
Out[]: 
2018-01-02 19:00:00    43
2018-01-02 20:00:00    44
2018-01-02 21:00:00    45
2018-01-02 22:00:00    46
2018-01-02 23:00:00    47
Freq: H, dtype: int64

以上代碼中，我們創建了以每小時為頻率的時間序列.

如果我們將以上數據轉換為按每天的數據統計：

In[]: ts.resample('D').sum()
Out[]: 
2018-01-01    276
2018-01-02    852
Freq: D, dtype: int64
# 先使用resample('D')方法指定了按天統計，接著使用sum方法求和了按天的所有數據（0-23相加，24-47相加）

# 當把底頻率的數據轉換成高頻率的數據時，默認情況下Pandas會引入NaN值，因為沒辦法從低頻率的數據計算出高頻率的數據，但可以通過fill_method參數指定插入值的方式：
In[]: ts.resample('D').mean().resample('H').mean()
Out[]: 
2018-01-01 00:00:00    11.5
2018-01-01 01:00:00     NaN
2018-01-01 02:00:00     NaN
2018-01-01 03:00:00     NaN
2018-01-01 04:00:00     NaN
2018-01-01 05:00:00     NaN
2018-01-01 06:00:00     NaN
2018-01-01 07:00:00     NaN
2018-01-01 08:00:00     NaN
2018-01-01 09:00:00     NaN
2018-01-01 10:00:00     NaN
2018-01-01 11:00:00     NaN
2018-01-01 12:00:00     NaN
2018-01-01 13:00:00     NaN
2018-01-01 14:00:00     NaN
2018-01-01 15:00:00     NaN
2018-01-01 16:00:00     NaN
2018-01-01 17:00:00     NaN
2018-01-01 18:00:00     NaN
2018-01-01 19:00:00     NaN
2018-01-01 20:00:00     NaN
2018-01-01 21:00:00     NaN
2018-01-01 22:00:00     NaN
2018-01-01 23:00:00     NaN
2018-01-02 00:00:00    35.5
Freq: H, dtype: float64

In[]: ts.resample('D').mean().resample('H').ffill()
# .fill()代表用前面的值替代NaN值
Out[]: 
2018-01-01 00:00:00    11.5
2018-01-01 01:00:00    11.5
2018-01-01 02:00:00    11.5
2018-01-01 03:00:00    11.5
2018-01-01 04:00:00    11.5
2018-01-01 05:00:00    11.5
2018-01-01 06:00:00    11.5
2018-01-01 07:00:00    11.5
2018-01-01 08:00:00    11.5
2018-01-01 09:00:00    11.5
2018-01-01 10:00:00    11.5
2018-01-01 11:00:00    11.5
2018-01-01 12:00:00    11.5
2018-01-01 13:00:00    11.5
2018-01-01 14:00:00    11.5
2018-01-01 15:00:00    11.5
2018-01-01 16:00:00    11.5
2018-01-01 17:00:00    11.5
2018-01-01 18:00:00    11.5
2018-01-01 19:00:00    11.5
2018-01-01 20:00:00    11.5
2018-01-01 21:00:00    11.5
2018-01-01 22:00:00    11.5
2018-01-01 23:00:00    11.5
2018-01-02 00:00:00    35.5
Freq: H, dtype: float64

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Python Pandas學習筆記。 vol4. 20190317

Python Pandas學習筆記。 vol4. 20190317

Series 和 DataFrame

Series:

DataFrame:

選擇

Series:

通過步長，用 iloc [[[間隔調用多行]]]:

DataFrame:

(1) 用標簽（列）選擇：

(2).選擇‘行’：

缺失值'NaN'和數據自動對齊

常用運算

常用統計：

數據合并和分組

自我理解：

自我理解分解：

通過一個元素查詢行數據

時間序列處理

生成日期范圍：

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Python Pandas學習筆記。 vol4. 20190317

Series 和 DataFrame

Series:

DataFrame:

選擇

Series:

通過步長，用 iloc [[[間隔調用多行]]]:

DataFrame:

(1) 用標簽（列）選擇：

(2).選擇‘行’：

缺失值'NaN'和數據自動對齊

常用運算

常用統計：

數據合并和分組

自我理解：

自我理解分解：

通過一個元素查詢行數據

時間序列處理

生成日期范圍：

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频