DMU_lzq1996
DMU_lzq1996

时间序列

#时间序列

#日期和时间数据类型及工具
from datetime import datetime
import pandas as pd
import numpy as np
now = datetime.now()
now

datetime.datetime(2018, 11, 7, 15, 6, 50, 327155)

now.year,now.month,now.day

(2018, 11, 7)

delta = datetime(2011,1,7) - datetime(2008,6,24,8,15)
delta#时间差

datetime.timedelta(days=926, seconds=56700)

delta.days

926

delta.seconds

56700

from datetime import timedelta#时间加减
start = datetime(2011,1,7)
start + timedelta(12)

datetime.datetime(2011, 1, 19, 0, 0)

start - 2*timedelta(12)

datetime.datetime(2010, 12, 14, 0, 0)

#字符串和datetime的相互转换
stamp = datetime(2011,1,3)
str(stamp)

'2011-01-03 00:00:00'

stamp.strftime('%Y-%m-%d,%H')

'2011-01-03,00'

value ='2011-01-03'
datetime.strptime(value,'%Y-%m-%d')

datetime.datetime(2011, 1, 3, 0, 0)

datestrs = ['07/06/2011','08/06/2011']
[datetime.strptime(x,'%m/%d/%Y')for x in datestrs]

[datetime.datetime(2011, 7, 6, 0, 0), datetime.datetime(2011, 8, 6, 0, 0)]

from dateutil.parser import parse
parse('2011-01-03')

datetime.datetime(2011, 1, 3, 0, 0)

 parse('Jan 31, 1997 10:45 PM')

datetime.datetime(1997, 1, 31, 22, 45)

parse('6/12/2011',dayfirst=True)

datetime.datetime(2011, 12, 6, 0, 0)

datestrs = ['2011-01-06 12:00:00','2011-01-01 00:00:00']
pd.to_datetime(datestrs)

DatetimeIndex(['2011-01-06 12:00:00', '2011-01-01 00:00:00'], dtype='datetime64[ns]', freq=None)

idx = pd.to_datetime(datestrs+[None])
idx

DatetimeIndex(['2011-01-06 12:00:00', '2011-01-01 00:00:00', 'NaT'], dtype='datetime64[ns]', freq=None)

idx[2]

NaT

pd.isnull(idx)

array([False, False,  True])

#时间序列基础
from datetime import datetime
dates = [datetime(2011, 1, 2), datetime(2011, 1, 5),
             datetime(2011, 1, 7), datetime(2011, 1, 8),
             datetime(2011, 1, 10), datetime(2011, 1, 12)]
ts = pd.Series(np.random.randn(6),index=dates)
ts

2011-01-02   -0.889247
2011-01-05    0.472529
2011-01-07    1.458923
2011-01-08    0.125811
2011-01-10    0.878417
2011-01-12   -1.347855
dtype: float64

ts.index

DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-07', '2011-01-08',
               '2011-01-10', '2011-01-12'],
              dtype='datetime64[ns]', freq=None)

ts[::2]

2011-01-02   -0.889247
2011-01-07    1.458923
2011-01-10    0.878417
dtype: float64

ts + ts[::2]

2011-01-02   -1.778493
2011-01-05         NaN
2011-01-07    2.917845
2011-01-08         NaN
2011-01-10    1.756833
2011-01-12         NaN
dtype: float64

ts.index.dtype

dtype('
stamp = ts.index[0]
stamp

Timestamp('2011-01-02 00:00:00')

#索引，选取，子集构造
stamp = ts.index[2]
ts[stamp]

1.4589225544193962

ts['1/10/2011']

0.8784166722932014

ts['20110110']

0.8784166722932014

longer_ts = pd.Series(np.random.randn(1000),
                     index = pd.date_range('1/1/2000',periods=1000))
longer_ts

2000-01-01   -1.016306
2000-01-02   -1.619848
2000-01-03   -1.030577
2000-01-04    0.782235
2000-01-05    0.380402
2000-01-06    1.867834
2000-01-07   -0.966920
2000-01-08    1.116943
2000-01-09    0.286488
2000-01-10    0.609803
2000-01-11    1.426519
2000-01-12    0.424936
2000-01-13   -1.196588
2000-01-14    0.906847
2000-01-15    0.266331
2000-01-16   -0.704134
2000-01-17    0.645805
2000-01-18    0.724744
2000-01-19    1.271031
2000-01-20   -0.622831
2000-01-21   -0.378951
2000-01-22   -0.978048
2000-01-23   -0.204337
2000-01-24    0.069203
2000-01-25    0.245822
2000-01-26    1.696828
2000-01-27   -0.754646
2000-01-28   -0.728572
2000-01-29    0.076263
2000-01-30    2.723447
                ...   
2002-08-28    1.168994
2002-08-29    1.212782
2002-08-30   -0.568776
2002-08-31   -1.392654
2002-09-01   -0.353161
2002-09-02   -0.779683
2002-09-03   -0.740422
2002-09-04    0.582901
2002-09-05    0.543077
2002-09-06   -1.046154
2002-09-07    0.031932
2002-09-08   -1.062249
2002-09-09    0.911971
2002-09-10    0.312633
2002-09-11   -0.487974
2002-09-12   -0.681178
2002-09-13    0.606661
2002-09-14   -0.246001
2002-09-15   -0.375383
2002-09-16    1.651613
2002-09-17   -0.233456
2002-09-18   -1.442711
2002-09-19    0.620685
2002-09-20    0.731800
2002-09-21   -0.151031
2002-09-22    0.752516
2002-09-23   -0.788909
2002-09-24   -0.388959
2002-09-25   -1.466894
2002-09-26   -0.429725
Freq: D, Length: 1000, dtype: float64

longer_ts['2001']

2001-01-01   -0.515375
2001-01-02   -0.438227
2001-01-03    0.678962
2001-01-04    2.457332
2001-01-05    0.007770
2001-01-06    1.532512
2001-01-07    0.237520
2001-01-08    1.425760
2001-01-09    0.684237
2001-01-10   -0.340322
2001-01-11    0.232236
2001-01-12    1.615747
2001-01-13    0.365120
2001-01-14    0.324808
2001-01-15    0.015621
2001-01-16   -0.177306
2001-01-17    0.561159
2001-01-18    0.516523
2001-01-19   -1.058772
2001-01-20   -0.136410
2001-01-21   -0.016760
2001-01-22   -0.882206
2001-01-23   -0.976625
2001-01-24   -0.189113
2001-01-25   -0.984928
2001-01-26    1.502973
2001-01-27    0.058032
2001-01-28   -0.543902
2001-01-29    0.090189
2001-01-30   -0.505144
                ...   
2001-12-02   -0.553024
2001-12-03   -0.405266
2001-12-04   -0.567354
2001-12-05    0.094730
2001-12-06   -0.548641
2001-12-07   -0.592105
2001-12-08    1.558771
2001-12-09   -1.049105
2001-12-10    2.094203
2001-12-11    0.067828
2001-12-12    0.094673
2001-12-13   -0.883690
2001-12-14    0.216863
2001-12-15   -0.011448
2001-12-16   -0.276283
2001-12-17    2.146709
2001-12-18    0.123471
2001-12-19    1.448596
2001-12-20   -0.990181
2001-12-21   -0.723119
2001-12-22    0.506099
2001-12-23   -1.410846
2001-12-24    0.077442
2001-12-25   -0.586892
2001-12-26    0.302183
2001-12-27    0.821904
2001-12-28   -0.669978
2001-12-29   -0.238159
2001-12-30    0.177509
2001-12-31   -1.527928
Freq: D, Length: 365, dtype: float64

longer_ts['2001-05']

2001-05-01   -0.434947
2001-05-02   -1.013492
2001-05-03   -1.370608
2001-05-04   -0.278787
2001-05-05   -0.527465
2001-05-06   -0.794392
2001-05-07   -0.688821
2001-05-08   -0.174579
2001-05-09    0.327301
2001-05-10    0.231338
2001-05-11   -1.600751
2001-05-12   -1.305738
2001-05-13    0.198962
2001-05-14    1.608539
2001-05-15   -1.017836
2001-05-16    1.837142
2001-05-17   -0.213202
2001-05-18   -0.372286
2001-05-19    0.139703
2001-05-20    1.092866
2001-05-21    0.089208
2001-05-22    0.404983
2001-05-23    2.775343
2001-05-24    0.077524
2001-05-25   -0.143234
2001-05-26   -0.559451
2001-05-27    0.753692
2001-05-28    0.373406
2001-05-29    0.566619
2001-05-30    0.539838
2001-05-31    0.044411
Freq: D, dtype: float64

ts[datetime(2011,1,7):]

2011-01-07    1.458923
2011-01-08    0.125811
2011-01-10    0.878417
2011-01-12   -1.347855
dtype: float64

ts['1/6/2011':'1/11/2011']

2011-01-07    1.458923
2011-01-08    0.125811
2011-01-10    0.878417
dtype: float64

ts.truncate(after='1/9/2011')

2011-01-02   -0.889247
2011-01-05    0.472529
2011-01-07    1.458923
2011-01-08    0.125811
dtype: float64

dates = pd.date_range('1/1/2000', periods=100, freq='W-WED')
long_df = pd.DataFrame(np.random.randn(100, 4),
                         index=dates,
                          columns=['Colorado', 'Texas',
                                    'New York', 'Ohio'])
long_df.loc['5-2001']
Colorado Texas New York Ohio
2001-05-02 0.534672 0.471547 0.102840 0.307940
2001-05-09 -1.078103 0.024223 -1.152705 0.382906
2001-05-16 -1.149617 -0.889391 -2.160858 0.730430
2001-05-23 0.970990 -0.440826 -0.329939 -1.671497
2001-05-30 0.122803 0.703133 -0.176191 -0.722155 
#带重复索引的时间序列
dates = pd.DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000',
                              '1/2/2000', '1/3/2000'])
dup_ts = pd.Series(np.arange(5),index=dates)
dup_ts

2000-01-01    0
2000-01-02    1
2000-01-02    2
2000-01-02    3
2000-01-03    4
dtype: int32

dup_ts['1/3/2000']

4

dup_ts['1/2/2000']

2000-01-02    1
2000-01-02    2
2000-01-02    3
dtype: int32

grouped = dup_ts.groupby(level=0)
grouped.mean()

2000-01-01    0
2000-01-02    2
2000-01-03    4
dtype: int32

grouped.count()

2000-01-01    1
2000-01-02    3
2000-01-03    1
dtype: int64

#日期范围，频率以及移动
ts

2011-01-02   -0.889247
2011-01-05    0.472529
2011-01-07    1.458923
2011-01-08    0.125811
2011-01-10    0.878417
2011-01-12   -1.347855
dtype: float64

resample = ts.resample('D')#D:每天

DatetimeIndexResampler [freq=, axis=0, closed=left, label=left, convention=start, base=0]

#生成日期范围
index = pd.date_range('2012-04-01','2012-06-01')
index

DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
               '2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
               '2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
               '2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
               '2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20',
               '2012-04-21', '2012-04-22', '2012-04-23', '2012-04-24',
               '2012-04-25', '2012-04-26', '2012-04-27', '2012-04-28',
               '2012-04-29', '2012-04-30', '2012-05-01', '2012-05-02',
               '2012-05-03', '2012-05-04', '2012-05-05', '2012-05-06',
               '2012-05-07', '2012-05-08', '2012-05-09', '2012-05-10',
               '2012-05-11', '2012-05-12', '2012-05-13', '2012-05-14',
               '2012-05-15', '2012-05-16', '2012-05-17', '2012-05-18',
               '2012-05-19', '2012-05-20', '2012-05-21', '2012-05-22',
               '2012-05-23', '2012-05-24', '2012-05-25', '2012-05-26',
               '2012-05-27', '2012-05-28', '2012-05-29', '2012-05-30',
               '2012-05-31', '2012-06-01'],
              dtype='datetime64[ns]', freq='D')

pd.date_range(start='2012-04-01',periods=20)

DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
               '2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
               '2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
               '2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
               '2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20'],
              dtype='datetime64[ns]', freq='D')

pd.date_range(end='2012-06-01',periods=20)

DatetimeIndex(['2012-05-13', '2012-05-14', '2012-05-15', '2012-05-16',
               '2012-05-17', '2012-05-18', '2012-05-19', '2012-05-20',
               '2012-05-21', '2012-05-22', '2012-05-23', '2012-05-24',
               '2012-05-25', '2012-05-26', '2012-05-27', '2012-05-28',
               '2012-05-29', '2012-05-30', '2012-05-31', '2012-06-01'],
              dtype='datetime64[ns]', freq='D')

pd.date_range('2000-01-01','2000-12-01',freq='BM')

DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-04-28',
               '2000-05-31', '2000-06-30', '2000-07-31', '2000-08-31',
               '2000-09-29', '2000-10-31', '2000-11-30'],
              dtype='datetime64[ns]', freq='BM')

pd.date_range('2012-05-20 12:56:31',periods=5)

DatetimeIndex(['2012-05-20 12:56:31', '2012-05-21 12:56:31',
               '2012-05-22 12:56:31', '2012-05-23 12:56:31',
               '2012-05-24 12:56:31'],
              dtype='datetime64[ns]', freq='D')

pd.date_range('2012-05-02 12:56:31', periods=5, normalize=True)

DatetimeIndex(['2012-05-02', '2012-05-03', '2012-05-04', '2012-05-05',
               '2012-05-06'],
              dtype='datetime64[ns]', freq='D')

#频率和日期偏移量
from pandas.tseries.offsets import Hour,Minute
hour =Hour()
hour



four_hours = Hour(4)
four_hours

<4 * Hours>

 pd.date_range('2000-01-01', '2000-01-03 23:59', freq='4h')

DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 04:00:00',
               '2000-01-01 08:00:00', '2000-01-01 12:00:00',
               '2000-01-01 16:00:00', '2000-01-01 20:00:00',
               '2000-01-02 00:00:00', '2000-01-02 04:00:00',
               '2000-01-02 08:00:00', '2000-01-02 12:00:00',
               '2000-01-02 16:00:00', '2000-01-02 20:00:00',
               '2000-01-03 00:00:00', '2000-01-03 04:00:00',
               '2000-01-03 08:00:00', '2000-01-03 12:00:00',
               '2000-01-03 16:00:00', '2000-01-03 20:00:00'],
              dtype='datetime64[ns]', freq='4H')

Hour(2) + Minute(30)

<150 * Minutes>

pd.date_range('2000-01-01', periods=10, freq='1h30min')

DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 01:30:00',
               '2000-01-01 03:00:00', '2000-01-01 04:30:00',
               '2000-01-01 06:00:00', '2000-01-01 07:30:00',
               '2000-01-01 09:00:00', '2000-01-01 10:30:00',
               '2000-01-01 12:00:00', '2000-01-01 13:30:00'],
              dtype='datetime64[ns]', freq='90T')

#WOM日期
rng = pd.date_range('2012-01-01', '2012-09-01', freq='WOM-3FRI')#每月第三个星期五
list(rng)


[Timestamp('2012-01-20 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-02-17 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-03-16 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-04-20 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-05-18 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-06-15 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-07-20 00:00:00', freq='WOM-3FRI'),
 Timestamp('2012-08-17 00:00:00', freq='WOM-3FRI')]

#移动数据
ts = pd.Series(np.random.randn(4),
                   index=pd.date_range('1/1/2000', periods=4, freq='M'))
ts

2000-01-31    0.177721
2000-02-29   -0.202120
2000-03-31   -0.701722
2000-04-30   -0.938393
Freq: M, dtype: float64

ts.shift(2)

2000-01-31         NaN
2000-02-29         NaN
2000-03-31    0.177721
2000-04-30   -0.202120
Freq: M, dtype: float64

#移动时间戳
ts.shift(2, freq='M')

2000-03-31    0.177721
2000-04-30   -0.202120
2000-05-31   -0.701722
2000-06-30   -0.938393
Freq: M, dtype: float64

#通过偏移量对日期进行位移
from pandas.tseries.offsets import Day, MonthEnd
now = datetime(2011, 11, 17)
now + 3 * Day()

Timestamp('2011-11-20 00:00:00')

 now + MonthEnd()

Timestamp('2011-11-30 00:00:00')

offset = MonthEnd()
offset.rollforward(now)

Timestamp('2011-11-30 00:00:00')

offset.rollback(now)

Timestamp('2011-10-31 00:00:00')

ts = pd.Series(np.random.randn(20),
                index=pd.date_range('1/15/2000', periods=20, freq='4d'))
ts

2000-01-15    2.441955
2000-01-19    0.062600
2000-01-23   -0.300315
2000-01-27    1.181993
2000-01-31    0.572116
2000-02-04    1.209064
2000-02-08   -0.996346
2000-02-12    0.890940
2000-02-16    0.194561
2000-02-20    0.233563
2000-02-24    0.380644
2000-02-28    0.117173
2000-03-03   -0.088754
2000-03-07   -0.206632
2000-03-11   -1.792495
2000-03-15   -0.443086
2000-03-19   -0.229585
2000-03-23   -1.429532
2000-03-27   -1.059541
2000-03-31   -1.274479
Freq: 4D, dtype: float64

ts.groupby(offset.rollforward).mean()

2000-01-31    0.791670
2000-02-29    0.289943
2000-03-31   -0.815513
dtype: float64

#时区处理
import pytz
pytz.common_timezones[-5:]

['US/Eastern', 'US/Hawaii', 'US/Mountain', 'US/Pacific', 'UTC']

#时区本地化和转换
rng = pd.date_range('3/9/2012 9:30',periods=6,freq='D')
ts = pd.Series(np.random.randn(len(rng)),index=rng)
ts

2012-03-09 09:30:00   -0.351911
2012-03-10 09:30:00    0.693718
2012-03-11 09:30:00    0.634782
2012-03-12 09:30:00    0.025861
2012-03-13 09:30:00   -0.142429
2012-03-14 09:30:00   -0.464828
Freq: D, dtype: float64

print(ts.index.tz)

None

pd.date_range('3/9/2012 9:30', periods=10, freq='D', tz='UTC')

DatetimeIndex(['2012-03-09 09:30:00+00:00', '2012-03-10 09:30:00+00:00',
               '2012-03-11 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
               '2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00',
               '2012-03-15 09:30:00+00:00', '2012-03-16 09:30:00+00:00',
               '2012-03-17 09:30:00+00:00', '2012-03-18 09:30:00+00:00'],
              dtype='datetime64[ns, UTC]', freq='D')

ts_utc = ts.tz_localize('UTC')
ts_utc

2012-03-09 09:30:00+00:00   -0.351911
2012-03-10 09:30:00+00:00    0.693718
2012-03-11 09:30:00+00:00    0.634782
2012-03-12 09:30:00+00:00    0.025861
2012-03-13 09:30:00+00:00   -0.142429
2012-03-14 09:30:00+00:00   -0.464828
Freq: D, dtype: float64

ts_utc.tz_convert('America/New_York')

2012-03-09 04:30:00-05:00   -0.351911
2012-03-10 04:30:00-05:00    0.693718
2012-03-11 05:30:00-04:00    0.634782
2012-03-12 05:30:00-04:00    0.025861
2012-03-13 05:30:00-04:00   -0.142429
2012-03-14 05:30:00-04:00   -0.464828
Freq: D, dtype: float64

#操作时区意识型Timestamp对象
stamp = pd.Timestamp('2011-03-12 04:00')
stamp_utc = stamp.tz_localize('utc')
stamp_utc.tz_convert('America/New_York')

Timestamp('2011-03-11 23:00:00-0500', tz='America/New_York')

stamp_moscow = pd.Timestamp('2011-03-12 04:00', tz='Europe/Moscow')
stamp_moscow

Timestamp('2011-03-12 04:00:00+0300', tz='Europe/Moscow')

stamp_utc.value

1299902400000000000

#不同时区之间的运算
rng = pd.date_range('3/7/2012 9:30', periods=10, freq='B')
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts

2012-03-07 09:30:00   -0.454626
2012-03-08 09:30:00   -0.102485
2012-03-09 09:30:00    0.309211
2012-03-12 09:30:00    0.249732
2012-03-13 09:30:00   -0.254658
2012-03-14 09:30:00   -0.503452
2012-03-15 09:30:00    1.722681
2012-03-16 09:30:00    0.090046
2012-03-19 09:30:00    1.414297
2012-03-20 09:30:00    0.126887
Freq: B, dtype: float64

ts1 = ts[:7].tz_localize('Europe/London')
ts2 = ts1[2:].tz_convert('Europe/Moscow')
result = ts1 + ts2 
result.index

DatetimeIndex(['2012-03-07 09:30:00+00:00', '2012-03-08 09:30:00+00:00',
               '2012-03-09 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
               '2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00',
               '2012-03-15 09:30:00+00:00'],
              dtype='datetime64[ns, UTC]', freq='B')

#时期及其算术运算
p = pd.Period(2007,freq='A-DEC')
p

Period('2007', 'A-DEC')

p + 5

Period('2012', 'A-DEC')

p - 2

Period('2005', 'A-DEC')

pd.Period('2014',freq='A-DEC') - p

7

rng = pd.period_range('2000-01-01','2000-06-30',freq='M')
rng

PeriodIndex(['2000-01', '2000-02', '2000-03', '2000-04', '2000-05', '2000-06'], dtype='period[M]', freq='M')

pd.Series(np.random.randn(6),index=rng)

2000-01    0.143415
2000-02   -0.355323
2000-03   -1.136658
2000-04    0.533440
2000-05    0.504703
2000-06   -0.723782
Freq: M, dtype: float64

values = ['2001Q3','2002Q2','2003Q1']
index = pd.PeriodIndex(values,freq='Q-DEC')
index


PeriodIndex(['2001Q3', '2002Q2', '2003Q1'], dtype='period[Q-DEC]', freq='Q-DEC')

#时期的频率转换
p = pd.Period('2007',freq='A-DEC')
p

Period('2007', 'A-DEC')

p.asfreq('M',how='start')

Period('2007-01', 'M')

p.asfreq('M',how='end')

Period('2007-12', 'M')

#按季度计算的时期频率
p = pd.Period('2012Q4',freq='Q-JAN')
p

Period('2012Q4', 'Q-JAN')

#将Timestamp转化为Period
rng = pd.date_range('2000-01-01',periods=3,freq='M')
ts = pd.Series(np.random.randn(3),index=rng)
ts

2000-01-31   -0.510447
2000-02-29   -0.624095
2000-03-31   -1.085284
Freq: M, dtype: float64

pts=ts.to_period()
pts

2000-01   -0.510447
2000-02   -0.624095
2000-03   -1.085284
Freq: M, dtype: float64

rng = pd.date_range('1/29/2000',periods=6,freq='D')
ts2 = pd.Series(np.random.randn(6),index=rng)
ts2


2000-01-29   -0.869026
2000-01-30    0.206545
2000-01-31   -0.147305
2000-02-01   -0.151367
2000-02-02    0.950917
2000-02-03    1.198447
Freq: D, dtype: float64

ts2.to_period('M')

2000-01   -0.869026
2000-01    0.206545
2000-01   -0.147305
2000-02   -0.151367
2000-02    0.950917
2000-02    1.198447
Freq: M, dtype: float64

pts = ts2.to_period()
pts

2000-01-29   -0.869026
2000-01-30    0.206545
2000-01-31   -0.147305
2000-02-01   -0.151367
2000-02-02    0.950917
2000-02-03    1.198447
Freq: D, dtype: float64

pts.to_timestamp(how='end')

2000-01-29   -0.869026
2000-01-30    0.206545
2000-01-31   -0.147305
2000-02-01   -0.151367
2000-02-02    0.950917
2000-02-03    1.198447
Freq: D, dtype: float64

#通过数组创建PeriodIndex
data = pd.read_csv('examples/macrodata.csv')
data.head(5)
year quarter realgdp realcons realinv realgovt realdpi cpi m1 tbilrate unemp pop infl realint
0 1959.0 1.0 2710.349 1707.4 286.898 470.045 1886.9 28.98 139.7 2.82 5.8 177.146 0.00 0.00
1 1959.0 2.0 2778.801 1733.7 310.859 481.301 1919.7 29.15 141.7 3.08 5.1 177.830 2.34 0.74
2 1959.0 3.0 2775.488 1751.8 289.226 491.260 1916.4 29.35 140.5 3.82 5.3 178.657 2.74 1.09
3 1959.0 4.0 2785.204 1753.7 299.356 484.052 1931.3 29.37 140.0 4.33 5.6 179.386 0.27 4.06
4 1960.0 1.0 2847.699 1770.5 331.722 462.199 1955.5 29.54 139.6 3.50 5.2 180.007 2.31 1.19 
data.year

0      1959.0
1      1959.0
2      1959.0
3      1959.0
4      1960.0
5      1960.0
6      1960.0
7      1960.0
8      1961.0
9      1961.0
10     1961.0
11     1961.0
12     1962.0
13     1962.0
14     1962.0
15     1962.0
16     1963.0
17     1963.0
18     1963.0
19     1963.0
20     1964.0
21     1964.0
22     1964.0
23     1964.0
24     1965.0
25     1965.0
26     1965.0
27     1965.0
28     1966.0
29     1966.0
        ...  
173    2002.0
174    2002.0
175    2002.0
176    2003.0
177    2003.0
178    2003.0
179    2003.0
180    2004.0
181    2004.0
182    2004.0
183    2004.0
184    2005.0
185    2005.0
186    2005.0
187    2005.0
188    2006.0
189    2006.0
190    2006.0
191    2006.0
192    2007.0
193    2007.0
194    2007.0
195    2007.0
196    2008.0
197    2008.0
198    2008.0
199    2008.0
200    2009.0
201    2009.0
202    2009.0
Name: year, Length: 203, dtype: float64

data.quarter

0      1.0
1      2.0
2      3.0
3      4.0
4      1.0
5      2.0
6      3.0
7      4.0
8      1.0
9      2.0
10     3.0
11     4.0
12     1.0
13     2.0
14     3.0
15     4.0
16     1.0
17     2.0
18     3.0
19     4.0
20     1.0
21     2.0
22     3.0
23     4.0
24     1.0
25     2.0
26     3.0
27     4.0
28     1.0
29     2.0
      ... 
173    2.0
174    3.0
175    4.0
176    1.0
177    2.0
178    3.0
179    4.0
180    1.0
181    2.0
182    3.0
183    4.0
184    1.0
185    2.0
186    3.0
187    4.0
188    1.0
189    2.0
190    3.0
191    4.0
192    1.0
193    2.0
194    3.0
195    4.0
196    1.0
197    2.0
198    3.0
199    4.0
200    1.0
201    2.0
202    3.0
Name: quarter, Length: 203, dtype: float64

index = pd.PeriodIndex(year=data.year,quarter=data.quarter,freq='Q-DEC')
index

PeriodIndex(['1959Q1', '1959Q2', '1959Q3', '1959Q4', '1960Q1', '1960Q2',
             '1960Q3', '1960Q4', '1961Q1', '1961Q2',
             ...
             '2007Q2', '2007Q3', '2007Q4', '2008Q1', '2008Q2', '2008Q3',
             '2008Q4', '2009Q1', '2009Q2', '2009Q3'],
            dtype='period[Q-DEC]', length=203, freq='Q-DEC')

data.index = index

data
year quarter realgdp realcons realinv realgovt realdpi cpi m1 tbilrate unemp pop infl realint
1959Q1 1959.0 1.0 2710.349 1707.4 286.898 470.045 1886.9 28.980 139.7 2.82 5.8 177.146 0.00 0.00
1959Q2 1959.0 2.0 2778.801 1733.7 310.859 481.301 1919.7 29.150 141.7 3.08 5.1 177.830 2.34 0.74
1959Q3 1959.0 3.0 2775.488 1751.8 289.226 491.260 1916.4 29.350 140.5 3.82 5.3 178.657 2.74 1.09
1959Q4 1959.0 4.0 2785.204 1753.7 299.356 484.052 1931.3 29.370 140.0 4.33 5.6 179.386 0.27 4.06
1960Q1 1960.0 1.0 2847.699 1770.5 331.722 462.199 1955.5 29.540 139.6 3.50 5.2 180.007 2.31 1.19
1960Q2 1960.0 2.0 2834.390 1792.9 298.152 460.400 1966.1 29.550 140.2 2.68 5.2 180.671 0.14 2.55
1960Q3 1960.0 3.0 2839.022 1785.8 296.375 474.676 1967.8 29.750 140.9 2.36 5.6 181.528 2.70 -0.34
1960Q4 1960.0 4.0 2802.616 1788.2 259.764 476.434 1966.6 29.840 141.1 2.29 6.3 182.287 1.21 1.08
1961Q1 1961.0 1.0 2819.264 1787.7 266.405 475.854 1984.5 29.810 142.1 2.37 6.8 182.992 -0.40 2.77
1961Q2 1961.0 2.0 2872.005 1814.3 286.246 480.328 2014.4 29.920 142.9 2.29 7.0 183.691 1.47 0.81
1961Q3 1961.0 3.0 2918.419 1823.1 310.227 493.828 2041.9 29.980 144.1 2.32 6.8 184.524 0.80 1.52
1961Q4 1961.0 4.0 2977.830 1859.6 315.463 502.521 2082.0 30.040 145.2 2.60 6.2 185.242 0.80 1.80
1962Q1 1962.0 1.0 3031.241 1879.4 334.271 520.960 2101.7 30.210 146.4 2.73 5.6 185.874 2.26 0.47
1962Q2 1962.0 2.0 3064.709 1902.5 331.039 523.066 2125.2 30.220 146.5 2.78 5.5 186.538 0.13 2.65
1962Q3 1962.0 3.0 3093.047 1917.9 336.962 538.838 2137.0 30.380 146.7 2.78 5.6 187.323 2.11 0.67
1962Q4 1962.0 4.0 3100.563 1945.1 325.650 535.912 2154.6 30.440 148.3 2.87 5.5 188.013 0.79 2.08
1963Q1 1963.0 1.0 3141.087 1958.2 343.721 522.917 2172.5 30.480 149.7 2.90 5.8 188.580 0.53 2.38
1963Q2 1963.0 2.0 3180.447 1976.9 348.730 518.108 2193.1 30.690 151.3 3.03 5.7 189.242 2.75 0.29
1963Q3 1963.0 3.0 3240.332 2003.8 360.102 546.893 2217.9 30.750 152.6 3.38 5.5 190.028 0.78 2.60
1963Q4 1963.0 4.0 3264.967 2020.6 364.534 532.383 2254.6 30.940 153.7 3.52 5.6 190.668 2.46 1.06
1964Q1 1964.0 1.0 3338.246 2060.5 379.523 529.686 2299.6 30.950 154.8 3.51 5.5 191.245 0.13 3.38
1964Q2 1964.0 2.0 3376.587 2096.7 377.778 526.175 2362.1 31.020 156.8 3.47 5.2 191.889 0.90 2.57
1964Q3 1964.0 3.0 3422.469 2135.2 386.754 522.008 2392.7 31.120 159.2 3.53 5.0 192.631 1.29 2.25
1964Q4 1964.0 4.0 3431.957 2141.2 389.910 514.603 2420.4 31.280 160.7 3.76 5.0 193.223 2.05 1.71
1965Q1 1965.0 1.0 3516.251 2188.8 429.145 508.006 2447.4 31.380 162.0 3.93 4.9 193.709 1.28 2.65
1965Q2 1965.0 2.0 3563.960 2213.0 429.119 508.931 2474.5 31.580 163.1 3.84 4.7 194.303 2.54 1.30
1965Q3 1965.0 3.0 3636.285 2251.0 444.444 529.446 2542.6 31.650 166.0 3.93 4.4 194.997 0.89 3.04
1965Q4 1965.0 4.0 3724.014 2314.3 446.493 544.121 2594.1 31.880 169.1 4.35 4.1 195.539 2.90 1.46
1966Q1 1966.0 1.0 3815.423 2348.5 484.244 556.593 2618.4 32.280 171.8 4.62 3.9 195.999 4.99 -0.37
1966Q2 1966.0 2.0 3828.124 2354.5 475.408 571.371 2624.7 32.450 170.3 4.65 3.8 196.560 2.10 2.55
... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
2002Q2 2002.0 2.0 11538.770 7997.8 1810.779 774.408 8658.9 180.000 1199.5 1.70 5.8 288.028 1.56 0.14
2002Q3 2002.0 3.0 11596.430 8052.0 1814.531 786.673 8629.2 181.200 1204.0 1.61 5.7 288.783 2.66 -1.05
2002Q4 2002.0 4.0 11598.824 8080.6 1813.219 799.967 8649.6 182.600 1226.8 1.20 5.8 289.421 3.08 -1.88
2003Q1 2003.0 1.0 11645.819 8122.3 1813.141 800.196 8681.3 183.200 1248.4 1.14 5.9 290.019 1.31 -0.17
2003Q2 2003.0 2.0 11738.706 8197.8 1823.698 838.775 8812.5 183.700 1287.9 0.96 6.2 290.704 1.09 -0.13
2003Q3 2003.0 3.0 11935.461 8312.1 1889.883 839.598 8935.4 184.900 1297.3 0.94 6.1 291.449 2.60 -1.67
2003Q4 2003.0 4.0 12042.817 8358.0 1959.783 845.722 8986.4 186.300 1306.1 0.90 5.8 292.057 3.02 -2.11
2004Q1 2004.0 1.0 12127.623 8437.6 1970.015 856.570 9025.9 187.400 1332.1 0.94 5.7 292.635 2.35 -1.42
2004Q2 2004.0 2.0 12213.818 8483.2 2055.580 861.440 9115.0 189.100 1340.5 1.21 5.6 293.310 3.61 -2.41
2004Q3 2004.0 3.0 12303.533 8555.8 2082.231 876.385 9175.9 190.800 1361.0 1.63 5.4 294.066 3.58 -1.95
2004Q4 2004.0 4.0 12410.282 8654.2 2125.152 865.596 9303.4 191.800 1366.6 2.20 5.4 294.741 2.09 0.11
2005Q1 2005.0 1.0 12534.113 8719.0 2170.299 869.204 9189.6 193.800 1357.8 2.69 5.3 295.308 4.15 -1.46
2005Q2 2005.0 2.0 12587.535 8802.9 2131.468 870.044 9253.0 194.700 1366.6 3.01 5.1 295.994 1.85 1.16
2005Q3 2005.0 3.0 12683.153 8865.6 2154.949 890.394 9308.0 199.200 1375.0 3.52 5.0 296.770 9.14 -5.62
2005Q4 2005.0 4.0 12748.699 8888.5 2232.193 875.557 9358.7 199.400 1380.6 4.00 4.9 297.435 0.40 3.60
2006Q1 2006.0 1.0 12915.938 8986.6 2264.721 900.511 9533.8 200.700 1380.5 4.51 4.7 298.061 2.60 1.91
2006Q2 2006.0 2.0 12962.462 9035.0 2261.247 892.839 9617.3 202.700 1369.2 4.82 4.7 298.766 3.97 0.85
2006Q3 2006.0 3.0 12965.916 9090.7 2229.636 892.002 9662.5 201.900 1369.4 4.90 4.7 299.593 -1.58 6.48
2006Q4 2006.0 4.0 13060.679 9181.6 2165.966 894.404 9788.8 203.574 1373.6 4.92 4.4 300.320 3.30 1.62
2007Q1 2007.0 1.0 13099.901 9265.1 2132.609 882.766 9830.2 205.920 1379.7 4.95 4.5 300.977 4.58 0.36
2007Q2 2007.0 2.0 13203.977 9291.5 2162.214 898.713 9842.7 207.338 1370.0 4.72 4.5 301.714 2.75 1.97
2007Q3 2007.0 3.0 13321.109 9335.6 2166.491 918.983 9883.9 209.133 1379.2 4.00 4.7 302.509 3.45 0.55
2007Q4 2007.0 4.0 13391.249 9363.6 2123.426 925.110 9886.2 212.495 1377.4 3.01 4.8 303.204 6.38 -3.37
2008Q1 2008.0 1.0 13366.865 9349.6 2082.886 943.372 9826.8 213.997 1384.0 1.56 4.9 303.803 2.82 -1.26
2008Q2 2008.0 2.0 13415.266 9351.0 2026.518 961.280 10059.0 218.610 1409.3 1.74 5.4 304.483 8.53 -6.79
2008Q3 2008.0 3.0 13324.600 9267.7 1990.693 991.551 9838.3 216.889 1474.7 1.17 6.0 305.270 -3.16 4.33
2008Q4 2008.0 4.0 13141.920 9195.3 1857.661 1007.273 9920.4 212.174 1576.5 0.12 6.9 305.952 -8.79 8.91
2009Q1 2009.0 1.0 12925.410 9209.2 1558.494 996.287 9926.4 212.671 1592.8 0.22 8.1 306.547 0.94 -0.71
2009Q2 2009.0 2.0 12901.504 9189.0 1456.678 1023.528 10077.5 214.469 1653.6 0.18 9.2 307.226 3.37 -3.19
2009Q3 2009.0 3.0 12990.341 9256.0 1486.398 1044.088 10040.6 216.385 1673.9 0.12 9.6 308.013 3.56 -3.44

203 rows × 14 columns

#重采样及频率转换
#重采样（resampling）指的是将时间序列从一个频率转换到另一个频率的处理过程
rng = pd.date_range('2000-01-01',periods=100,freq='D')
ts = pd.Series(np.random.randn(len(rng)),index=rng)
ts

2000-01-01    0.014440
2000-01-02    0.676634
2000-01-03    0.828413
2000-01-04    1.809659
2000-01-05    0.346060
2000-01-06   -0.906748
2000-01-07   -0.144737
2000-01-08   -0.376248
2000-01-09   -1.811051
2000-01-10    0.422918
2000-01-11   -0.291923
2000-01-12   -0.947770
2000-01-13    2.794186
2000-01-14   -1.314019
2000-01-15   -0.474217
2000-01-16    0.657007
2000-01-17   -1.604424
2000-01-18   -0.387496
2000-01-19    0.493891
2000-01-20   -0.963368
2000-01-21    1.689601
2000-01-22   -0.318659
2000-01-23    0.960378
2000-01-24   -0.241049
2000-01-25   -0.068125
2000-01-26   -0.755140
2000-01-27    1.123554
2000-01-28    0.775620
2000-01-29    0.141545
2000-01-30    0.200428
                ...   
2000-03-11    0.695305
2000-03-12   -0.418060
2000-03-13   -0.143606
2000-03-14   -1.265208
2000-03-15    0.016866
2000-03-16   -1.072653
2000-03-17    0.491403
2000-03-18   -0.973830
2000-03-19    1.357179
2000-03-20   -0.856155
2000-03-21    0.594472
2000-03-22   -1.938699
2000-03-23    1.890984
2000-03-24   -0.635768
2000-03-25   -0.239094
2000-03-26    0.281482
2000-03-27   -1.499055
2000-03-28   -1.219709
2000-03-29   -0.996651
2000-03-30    0.779328
2000-03-31   -1.139721
2000-04-01    1.624966
2000-04-02    0.988920
2000-04-03    0.940181
2000-04-04   -0.195757
2000-04-05   -0.140197
2000-04-06   -1.513569
2000-04-07   -1.563758
2000-04-08    0.216563
2000-04-09   -0.857682
Freq: D, Length: 100, dtype: float64

ts.resample('M',kind='Period').mean()

2000-01-31    0.079785
2000-02-29    0.057120
2000-03-31   -0.337746
2000-04-30   -0.055593
Freq: M, dtype: float64

#降采样
rng = pd.date_range('2000-01-01', periods=12, freq='T')
ts = pd.Series(np.arange(12), index=rng)
ts

2000-01-01 00:00:00     0
2000-01-01 00:01:00     1
2000-01-01 00:02:00     2
2000-01-01 00:03:00     3
2000-01-01 00:04:00     4
2000-01-01 00:05:00     5
2000-01-01 00:06:00     6
2000-01-01 00:07:00     7
2000-01-01 00:08:00     8
2000-01-01 00:09:00     9
2000-01-01 00:10:00    10
2000-01-01 00:11:00    11
Freq: T, dtype: int32

ts.resample('5min',closed='right').sum()

1999-12-31 23:55:00     0
2000-01-01 00:00:00    15
2000-01-01 00:05:00    40
2000-01-01 00:10:00    11
Freq: 5T, dtype: int32

ts.resample('5min',closed='right',label='right').sum()

2000-01-01 00:00:00     0
2000-01-01 00:05:00    15
2000-01-01 00:10:00    40
2000-01-01 00:15:00    11
Freq: 5T, dtype: int32

ts.resample('5min').ohlc()
open high low close
2000-01-01 00:00:00 0 4 0 4
2000-01-01 00:05:00 5 9 5 9
2000-01-01 00:10:00 10 11 10 11 
#通过时期进行重采样
frame = pd.DataFrame(np.random.randn(24, 4),
                         index=pd.period_range('1-2000', '12-2001',
                                              freq='M'),
                        columns=['Colorado', 'Texas', 'New York', 'Ohio'])
frame
Colorado Texas New York Ohio
2000-01 0.966322 -1.097520 0.278189 1.351895
2000-02 -0.440050 -1.486752 -0.281330 -0.083094
2000-03 -0.148903 0.074773 0.432271 -0.606501
2000-04 -0.324102 1.150940 -1.007997 0.192719
2000-05 0.018921 -0.463694 -0.915002 -1.167408
2000-06 1.098821 2.595297 -0.289931 0.624960
2000-07 1.173885 -1.247856 -1.546760 1.148165
2000-08 -2.465409 -0.976749 -0.565111 -2.461652
2000-09 -0.337638 -0.860959 0.585042 0.935459
2000-10 -0.422014 -0.233506 -1.239120 1.692123
2000-11 -0.010893 0.428696 -0.574149 -0.127551
2000-12 0.044093 1.085275 0.995065 0.893955
2001-01 -1.007087 -1.721242 0.328790 -0.536349
2001-02 -1.525735 0.391245 0.649280 1.114608
2001-03 0.398916 0.423673 0.442252 0.922619
2001-04 1.172961 0.726157 -0.860389 -0.263490
2001-05 1.293229 -0.104286 -0.973742 1.284994
2001-06 -0.620977 -0.288092 0.509420 -0.775555
2001-07 -0.249990 -0.075546 0.064330 -0.077252
2001-08 0.010249 -0.009822 1.467907 -0.932622
2001-09 -0.849710 -0.144258 0.384650 -1.102285
2001-10 -1.594351 0.561065 0.171580 0.385832
2001-11 -0.164112 1.495407 -0.688782 -1.025762
2001-12 -1.392290 1.441935 -0.185071 0.306422 
annual_frame = frame.resample('A-DEC').mean()
annual_frame
Colorado Texas New York Ohio
2000 -0.070581 -0.086005 -0.344069 0.199423
2001 -0.377408 0.224686 0.109186 -0.058237 
#移动窗口函数
close_px_all = pd.read_csv('examples/stock_px_2.csv',
                             parse_dates=True, index_col=0)
close_px = close_px_all[['AAPL', 'MSFT', 'XOM']]
close_px = close_px.resample('B').ffill()
close_px
AAPL MSFT XOM
2003-01-02 7.40 21.11 29.22
2003-01-03 7.45 21.14 29.24
2003-01-06 7.45 21.52 29.96
2003-01-07 7.43 21.93 28.95
2003-01-08 7.28 21.31 28.83
2003-01-09 7.34 21.93 29.44
2003-01-10 7.36 21.97 29.03
2003-01-13 7.32 22.16 28.91
2003-01-14 7.30 22.39 29.17
2003-01-15 7.22 22.11 28.77
2003-01-16 7.31 21.75 28.90
2003-01-17 7.05 20.22 28.60
2003-01-20 7.05 20.22 28.60
2003-01-21 7.01 20.17 27.94
2003-01-22 6.94 20.04 27.58
2003-01-23 7.09 20.54 27.52
2003-01-24 6.90 19.59 26.93
2003-01-27 7.07 19.32 26.21
2003-01-28 7.29 19.18 26.90
2003-01-29 7.47 19.61 27.88
2003-01-30 7.16 18.95 27.37
2003-01-31 7.18 18.65 28.13
2003-02-03 7.33 19.08 28.52
2003-02-04 7.30 18.59 28.52
2003-02-05 7.22 18.45 28.11
2003-02-06 7.22 18.63 27.87
2003-02-07 7.07 18.30 27.66
2003-02-10 7.18 18.62 27.87
2003-02-11 7.18 18.25 27.67
2003-02-12 7.20 18.25 27.12
... ... ... ...
2011-09-05 374.05 25.80 72.14
2011-09-06 379.74 25.51 71.15
2011-09-07 383.93 26.00 73.65
2011-09-08 384.14 26.22 72.82
2011-09-09 377.48 25.74 71.01
2011-09-12 379.94 25.89 71.84
2011-09-13 384.62 26.04 71.65
2011-09-14 389.30 26.50 72.64
2011-09-15 392.96 26.99 74.01
2011-09-16 400.50 27.12 74.55
2011-09-19 411.63 27.21 73.70
2011-09-20 413.45 26.98 74.01
2011-09-21 412.14 25.99 71.97
2011-09-22 401.82 25.06 69.24
2011-09-23 404.30 25.06 69.31
2011-09-26 403.17 25.44 71.72
2011-09-27 399.26 25.67 72.91
2011-09-28 397.01 25.58 72.07
2011-09-29 390.57 25.45 73.88
2011-09-30 381.32 24.89 72.63
2011-10-03 374.60 24.53 71.15
2011-10-04 372.50 25.34 72.83
2011-10-05 378.25 25.89 73.95
2011-10-06 377.37 26.34 73.89
2011-10-07 369.80 26.25 73.56
2011-10-10 388.81 26.94 76.28
2011-10-11 400.29 27.00 76.27
2011-10-12 402.19 26.96 77.16
2011-10-13 408.43 27.18 76.37
2011-10-14 422.00 27.27 78.11

2292 rows × 3 columns

close_px.AAPL.plot()




close_px.AAPL.rolling(250).mean().plot()




appl_std250 = close_px.AAPL.rolling(250, min_periods=10).std()
appl_std250[5:12]

2003-01-09         NaN
2003-01-10         NaN
2003-01-13         NaN
2003-01-14         NaN
2003-01-15    0.077496
2003-01-16    0.074760
2003-01-17    0.112368
Freq: B, Name: AAPL, dtype: float64

appl_std250.plot()

你可能感兴趣的:(利用python进行数据分析)

  • 打卡第13天：《利用python进行数据分析》学习笔记 且不了了
    第7章——数据规整化：清理、转换、合并、重塑数据变换http://nbviewer.jupyter.org/github/qiebuliaoliao/data_analysis_python/blob/master/ch7/20180405.ipynb
  • matplotlib和seaborn绘图 Oliveee
    https://www.jianshu.com/p/7a0eafdd1340《利用Python进行数据分析·第2版》第9章绘图和可视化matplotlib引入%matplotlibnotebookimportmatplotlib.pyplotasplt简单示例fig=plt.figure()ax1=fig.add_subplot(2,2,1)ax2=fig.add_subplot(2,2,2)ax
  • 《利用Python进行数据分析》 附录 A.3 广播 CCC考研
    附录A高阶NumpyA.3广播广播描述了算法如何在不同形状的数组之间进行运算。它是一个强大的功能，但可能会导致混淆，即使对于有经验的用户也是如此。1.最简单的广播示例发生在将标量值与数组组合的时候（见图A-1）图A-1:简单广播注：有关此操作的说明，请参见图A-2。对行进行减均值的广播需要更小心。幸运的是，只要遵循规则，就可以在数组的任何维度上对潜在较低维度值进行广播（例如从二维数组的每一列中减去
  • Week 02 Python初步 图小加
    本周是Python的基本使用，从真正小白零接触，跟着大神们开始学习参考书：利用Python进行数据分析（原书第2版）中第三章和第五章一、Python基础1）Python环境安装（1）下载anaconda是python的包管理器和环境管理器，是在conda（一个包管理器和环境管理器）上发展出来的。在数据分析中，将会用到很多第三方的包，而conda（包管理器）可以很方便地在计算机上安装和管理这些包，包
  • 《利用Python进行数据分析》 14.2 MovieLens 1M数据集 CCC考研
    第十四章数据分析示例注：本章示例数据集可在附带的GitHub仓库（http://github.com/wesm/pydata-book）中找到14.2MovieLens1M数据集GroupLens实验室（http://www.grouplens.org/node/73）提供了一些从MovieLens用户那里收集的20世纪90年代末和21世纪初的电影评分数据的集合。这些数据提供了电影的评分、电影的元
  • 2018-11-28 wangyou2550
    python书籍入门：python基础教程第二版，笨方法学python进阶：流畅的python，effictivepython，Python编程实战，编写高质量代码：python，python核心编程第三版，PythonCookbook中文版第3版计算：python科学计算，利用Python进行数据分析前端：FlaskWeb开发：基于Python的Web应用开发实战，DjangoWeb开发指南网络
  • 【读书笔记】《利用Python进行数据分析》第2版_第二章：Python语言基础、IPython及Jupyternotebook is_colorful pythonpythonpytorch深度学习
    推荐使用IPython命令行和Jupyternotebook来实验代码示例，以及探索各种类型、函数和方法的文档。和其他键盘控制的命令行环境一样，练就常用命令的肌肉记忆也是学习曲线的一部分。优秀Python书籍推荐《PythonCookbook》（第3版），作者为DavidBeazley和BrianK.Jones（O’Reilly）《FluentPython》，作者为LucianoRamalho（O
  • 利用python进行数据分析(第二版)_第十四章 shifanfashi 数据分析数据分析
    本书正文的最后一章，我们来看一些真实世界的数据集。对于每个数据集，我们会用之前介绍的方法，从原始数据中提取有意义的内容。展示的方法适用于其它数据集，也包括你的。本章包含了一些各种各样的案例数据集，可以用来练习。案例数据集可以在Github仓库找到，见第一章。#14.1来自Bitly的USA.gov数据2011年，URL缩短服务Bitly跟美国政府网站USA.gov合作，提供了一份从生成.gov或.
  • 利用Python进行数据分析的学习笔记——chap10 调停者จุ๊บ 笔记python开发语言后端
    时间序列日期和时间数据类型及工具fromdatetimeimportdatetimenow=datetime.now()nowdatetime.datetime(2022,3,4,8,23,31,842698)now.year,now.month,now.day(2022,3,4)#时间差delta=datetime(2022,3,3)-datetime(1998,10,20,8,10)delta
  • 利用python进行数据分析(1) Doter
    第一章一.数据的类型表格数据多维数据(矩阵)多张表数据(主外键关联)时间序列二.重要的Python库NumPy基础数据结构和函数pandas高级数据结构和函数matplotlib二维数据可视化IPython和Jupyter交互Scipy科学计算领域scikit-learn机器学习包statsmodels统计分析包第二章Python基础略第三章NumPy菜鸟教程比书详细第四章pandas易百教程最简
  • 学习python数据分析必看，《利用Python进行数据分析》 新潮看世界
    利用Python进行数据分析pdf:讲述了从pandas库的数据分析工具开始利用高性能工具、matpIotlib、pandas的groupby功能等处理各种各样的时间序列数据。
  • NumPy教程（一）—— ndarray：多维数组对象 m0_61766362 Numpypython学习笔记numpypython学习方法
    前言该numpy学习笔记参考了菜鸟教程网、b站up主孙兴华zz的《孙兴华中文讲python数据分析三部曲》以及《北理-python数据分析与展示》，课本推荐使用《利用python进行数据分析》Numpy简介：NumPy(NumericalPython)是Python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。1.数组(array)的介绍数组是相同数据
  • 字符串与正则表达式python实验报告分析_《利用Python进行数据分析》第7章 字符串操作与正则表达式... weixin_39615257
    字符串操作Python有简单易用的字符串和文本处理功能，大部分文本运算都直接做成了字符串对象的内置方法。对于更为复杂的模式匹配和文本操作，则可能需要用到正则表达式。字符串对象方法以逗号分隔的字符串可以用split拆分成数段In[4]:val='a,bc,c,gudio'In[5]:val.split(',')Out[5]:['a','bc','c','gudio']In[6]:val='a,bc,
  • chatgpt赋能python：Python统计总分——利用Python进行数据分析 laingziwei ChatGptpythonchatgpt开发语言计算机
    Python统计总分——利用Python进行数据分析Python是一门流行的编程语言，有着广泛的应用领域。其中，Python在数据分析和统计领域也发挥着重要作用。本文将介绍如何利用Python进行数据分析，进而实现统计总分的功能。什么是数据分析？数据分析是指用各种统计方法对数据进行处理和分析，以获取数据中的信息和规律，并进行有效的决策。在现代社会中，数据分析已经成为了各行各业必备的技能之一。而Py
  • 打卡第11天：《利用python进行数据分析》学习笔记 且不了了
    第五章——pandas入门第二部分：pandas主要功能（四）http://nbviewer.jupyter.org/github/qiebuliaoliao/data_analysis_python/blob/master/ch5/20180403.ipynb
  • day14：《利用python进行数据分析》学习笔记 且不了了
    第7章——数据规整化：清理、转换、合并、重塑字符串处理http://nbviewer.jupyter.org/github/qiebuliaoliao/data_analysis_python/blob/master/ch7/20180406.ipynb
  • 《利用Python进行数据分析》 13.1pandas与建模代码的结合 CCC考研
    第十三章Python建模库介绍13.1pandas与建模代码的结合使用pandas用于数据载入和数据清洗，之后切换到模型库去建立模型是一个常见的模型开发工作流。在机器学习中，特征工程是模型开发的重要部分之一。特征工程是指从原生数据集中提取可用于模型上下文的有效信息的数据转换过程或分析，书中会展示一些可以在利用pandas进行数据操作和建模之间无痛切换的方法。1.panas和其他分析库的结合点通常是
  • 利用python进行数据分析 第十四章 14.3 1880-2010年间全美婴儿姓名 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    14.31880-2010年间全美婴儿姓名美国社会保障总署（SSA）ᨀ供了一份从1880年到现在的婴儿名字频率数据。HadleyWickham（许多流行R包的作者）经常用这份数据来演示R的数据处理功能。我们要做一些数据规整才能加载这个数据集，这么做就会产生一个如下的DataFrame：In[4]:names.head(10)Out[4]:namesexbirthsyear0MaryF7065188
  • 利用python进行数据分析 第十四章 14.5 2012联邦选举委员会数据库 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    14.52012联邦选举委员会数据库美国联邦选举委员会发布了有关政治竞选赞助方面的数据。其中包括赞助者的姓名、职业、雇主、地址以及出资额等信息。我们对2012年美国总统大选的数据集比较感兴趣（http://www.fec.gov/disclosurep/PDownload.do）。我在2012年6月下载的数据集是一个150MB的CSV文件（P00000001-ALL.csv），我们先用pandas
  • 利用python进行数据分析 第十章 数据聚合与分组运算 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    对数据集进行分组并对各组应用一个函数（无论是聚合还是转换），通常是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后，通常就是计算分组统计或生成透视表。pandasᨀ供了一个灵活高效的gruopby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。关系型数据库和SQL（StructuredQueryLanguage，结构化查询语言）能够如此流行的原因之一就是其能够方便地对数
  • 利用python进行数据分析 第十三章 Python建模库介绍 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    本书中，我已经介绍了Python数据分析的编程基础。因为数据分析师和科学家总是在数据规整和准备上花费大量时间，这本书的重点在于掌握这些功能。开发模型选用什么库取决于应用本身。许多统计问题可以用简单方法解决，比如普通的最小二乘回归，其它问题可能需要复杂的机器学习方法。幸运的是，Python已经成为了运用这些分析方法的语言之一，因此读完此书，你可以探索许多工具。本章中，我会回顾一些pandas的特点，
  • 利用python进行数据分析 第九章 绘图和可视化 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    信息可视化（也叫绘图）是数据分析中最重要的工作之一。它可能是探索过程的一部分，例如，帮助我们找出异常值、必要的数据转换、得出有关模型的idea等。另外，做一个可交互的数据可视化也许是工作的最终目标。Python有许多库进行静态或动态的数据可视化，但我这里重要关注于matplotlib（http://matplotlib.org/）和基于它的库。matplotlib是一个用于创建出版质量图表的桌面绘
  • 利用python进行数据分析 第八章 数据规整：聚合、合并和重塑 小猞猁啥都学 利用Python进行数据分析python数据分析数据挖掘
    8.1层次化索引层次化索引（hierarchicalindexing）是pandas的一项重要功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：In[9]:data=pd.Series(np.random.randn(9),...:index=[['a','a'
  • 利用python进行数据分析 第七章 数据清洗和准备 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    7.1处理缺失数据在许多数据分析工作中，缺失数据是经常发生的。pandas的目标之一就是尽量轻松地处理缺失数据。例如，pandas对象的所有᧿述性统计默认都不包括缺失数据。缺失数据在pandas中呈现的方式有些不完美，但对于大多数用户可以保证功能正常。对于数值数据，pandas使用浮点值NaN（NotaNumber）表示缺失数据。我们称其为哨兵值，可以方便的检测出来：In[10]:string_d
  • 利用python进行数据分析 第六章 数据加载、存储与文件格式 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    访问数据是使用本书所介绍的这些工具的第一步。我会着重介绍pandas的数据输入与输出，虽然别的库中也有不少以此为目的的工具。输入输出通常可以划分为几个大类：读取文本文件和其他更高效的磁盘存储格式，加载数据库中的数据，利用WebAPI操作网络资源。6.1读写文本格式的数据pandasᨀ供了一些用于将表格型数据读取为DataFrame对象的函数。表6-1对它们进行了总结，其中read_csv和read
  • 利用python进行数据分析 第十四章 数据分析案例 小猞猁啥都学 利用Python进行数据分析python数据分析开发语言
    本书正文的最后一章，我们来看一些真实世界的数据集。对于每个数据集，我们会用之前介绍的方法，从原始数据中ᨀ取有意义的内容。展示的方法适用于其它数据集，也包括你的。本章包含了一些各种各样的案例数据集，可以用来练习。案例数据集可以在Github仓库找到，见第一章。14.1来自Bitly的USA.gov数据2011年，URL缩短服务Bitly跟美国政府网站USA.gov合作，ᨀ供了一份从生成.gov或.m
  • 2021-07-15 大竹英雄
    周四，对目前的项目进展进行一个简单的小结。对于python进行数据处理来说，pandas式一个不得不用的包，它比numpy很为强大。通过对《利用python进行数据分析》这本书中介绍pandas包的学习，再加以自己的理解，写下这篇随笔，与一起喜欢数据分析的朋友分享和相互学习。importnumpyasnpimportpandasaspdfrompandasimportSeries,DataFram
  • 利用Python进行数据分析（Ⅰ） 小灵宝 机器学习python机器学习数据分析大数据
    利用Python进行数据分析（Ⅰ）本文参考书籍：《利用Python进行数据分析》目录利用Python进行数据分析（Ⅰ）1.准备工作1.1重要的Python库NumPypandasmatplotlibIPython与JupyterSciPyscikit-learnstatsmodels导入约定术语2.Python基础、IPython及Jupyternotebook2.1IPython基础运行IPyt
  • 《利用Python进行数据分析》notebook solonebaeya
    目录Chapter1.准备工作Chapter2.Python语言基础、IPython及JupyternotebookChapter3.内建数据结构、函数及文件【元组、列表、字典、集合】Chapter1.准备工作包括环境搭建，编译器安装，重要python库的初识等入门内容。Chapter2.Python语言基础、IPython及Jupyternotebook2.1Python解释器交互式Python
  • 《利用Python进行数据分析》 附录 A.7 使用Numba编写快速NumPy函数 CCC考研
    附录A高阶NumpyA.7使用Numba编写快速NumPy函数Numba（http://numba.pydata.org）是一个开源项目，可为使用CPU、GPU或其他硬件的NumPy类型的数据创建快速函数。它使用LLVMProject（http://llvm.org）将Python代码翻译成编译后的机器码。1.让我们考虑一个纯Python函数，该函数使用for循环计算表达式(x-y).mean()
  • JAVA基础 灵静志远 位运算加载Date字符串池覆盖
    一、类的初始化顺序 1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器 同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。 二、String 1 String a = "abc"; JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
  • keepalived实现redis主从高可用 bylijinnan redis
    方案说明 两台机器（称为A和B），以统一的VIP对外提供服务 1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
  • java文件操作大全 0624chenhong java
    最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 一.获得控制台用户输入的信息    &nbs
  • android学习任务 不懂事的小屁孩 工作
    任务 完成情况 搞清楚带箭头的pupupwindows和不带的使用 已完成 熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成 熟练使用android的线程handler,并敲示例代码 进行中 了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar 研究一下android的动画效果，写一个实例 已完成 复习fragem
  • zoom.js 换个号韩国红果果 oom
    它的基于bootstrap 的 https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序 <link rel="stylesheet" href="style/zoom.css"> <script src=&q
  • 详解Oracle云操作系统Solaris 11.2 蓝儿唯美 Solaris
    当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。 
  • spring学习——springmvc（一） a-john springMVC
    Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。   1，跟踪Spring MVC的请求 请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
  • hdu4342 History repeat itself-------多校联合五 aijuans 数论
    水题就不多说什么了。 #include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--)
  • EJB和javabean的区别 asia007 beanejb
    EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了   1.EJB用于服务端应用开发, 而JavaBeans
  • Struts的action和Result总结 百合不是茶 strutsAction配置Result配置
        一:Action的配置详解:      下面是一个Struts中一个空的Struts.xml的配置文件     <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC &quo
  • 如何带好自已的团队 bijian1013 项目管理团队管理团队
    在网上看到博客" 怎么才能让团队成员好好干活"的评论，觉得写的比较好。 原文如下： 我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 1.诚信         对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
  • Java代码混淆工具 sunjing ProGuard
    Open Source Obfuscators ProGuard http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
  • 【Redis三】基于Redis sentinel的自动failover主从复制 bit1129 redis
    在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。   什么是Sentine
  • 使用代理实现Hibernate Dao层自动事务 白糖_ DAOspringAOP框架Hibernate
    都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 public void save(Object obj){ Session session = this.getSession(); Transaction tran = session.beginTransaction(); try
  • maven3实战读书笔记 braveCS maven3
    Maven简介 是什么？ Is a software project management and comprehension tool.项目管理工具 是基于POM概念(工程对象模型) [设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] [与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区]     功能：
  • 编程之美-子数组的最大乘积 bylijinnan 编程之美
    public class MaxProduct { /** * 编程之美 子数组的最大乘积 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。 * 但按题目的意思，是要求得这个子数组，而不
  • 读书笔记-2 chengxuyuancsdn 读书笔记
    1、反射 2、oracle年-月-日 时-分-秒 3、oracle创建有参、无参函数 4、oracle行转列 5、Struts2拦截器 6、Filter过滤器(web.xml) 1、反射 (1)检查类的结构 在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。 2、oracle年月日时分秒 s
  • [求学与房地产]慎重选择IT培训学校 comsci it
          关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题       培训学校的教学楼和宿舍的环境和稳定性问题       我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... &nb
  • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 daizj oraclermanfilespersetPARALLELISM
    RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转 PARALLELISM --- 我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： RMAN > configure device type disk parallelism 3 ; 表示启动三个通道，可以加快备份恢复的速度。
  • 简单排序:冒泡排序 dieslrae 冒泡排序
    public void bubbleSort(int[] array){ for(int i=1;i<array.length;i++){ for(int k=0;k<array.length-i;k++){ if(array[k] > array[k+1]){
  • 初二上学期难记单词三 dcj3sjt126com sciet
    concert 音乐会 tonight 今晚 famous 有名的；著名的 song 歌曲 thousand 千 accident 事故；灾难 careless 粗心的，大意的 break 折断；断裂；破碎 heart 心（脏） happen  偶尔发生，碰巧 tourist 旅游者；观光者 science （自然）科学 marry 结婚 subject 题目；
  • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码 dcj3sjt126com redis
    wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-stable make   前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。 异常一： make[2]: cc: Command not found 异常原因：没有安装g
  • 并发容器 shuizhaosi888 并发容器
       通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。    并发容器ConcurrentHashMap       替代同步基于散列的Map，通过Lock控制。   &nb
  • Spring Security（12）——Remember-Me功能 234390216 Spring SecurityRemember Me记住我
    Remember-Me功能   目录   1.1     概述 1.2     基于简单加密token的方法 1.3     基于持久化token的方法 1.4     Remember-Me相关接口和实现
  • 位运算 焦志广 位运算
    一、位运算符Ｃ语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 例如：9&am
  • nodejs 数据库连接 mongodb mysql liguangsong mongodbmysqlnode数据库连接
    1.mysql 连接    package.json中dependencies加入     "mysql":"~2.7.0"    执行 npm install      在config 下创建文件 database.js    
  • java动态编译 olive6615 javaHotSpotjvm动态编译
        在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。     HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
  • Storm0.9.5的集群部署配置优化 roadrunners 优化storm.yaml
    nimbus结点配置（storm.yaml）信息： # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional inf
  • 101个MySQL 的调节和优化的提示 tomcat_oracle mysql
    　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。 　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。 　　3. 使用电池供电的RAM（注：RAM即随机存储器）。 　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
  • zoj 3829 Known Notation(贪心) 阿尔萨斯 ZOJ
    题目链接：zoj 3829 Known Notation 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。 解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他