墨鱼精

10分钟 to pandas

import pandas as pd
import numpy as np
import matplotlib.pyplot as pltx

In [3]:

dates = pd.date_range('20130101', periods=6)
dates

Out[3]:

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

In [4]:

df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
df

Out[4]:

	A	B	C	D
2013-01-01	0.043660	0.914219	1.364281	0.960460
2013-01-02	0.245818	0.582317	0.456372	-0.734680
2013-01-03	-0.997398	-0.476202	0.967015	0.089730
2013-01-04	-1.132148	0.867161	0.458086	0.797743
2013-01-05	-1.226727	1.524988	-1.980305	0.694533
2013-01-06	1.695086	0.796078	-0.688947	-0.910752

In [5]:

df2 = pd.DataFrame({ 'A' : 1.,
              'B' : pd.Timestamp('20130102'),
              'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
              'D' : np.array([3] * 4,dtype='int32'),
              'E' : pd.Categorical(["test","train","test","train"]),
              'F' : 'foo' })
df2

Out[5]:

	A	B	C	D	E	F
0	1.0	2013-01-02	1.0	3	test	foo
1	1.0	2013-01-02	1.0	3	train	foo
2	1.0	2013-01-02	1.0	3	test	foo
3	1.0	2013-01-02	1.0	3	train	foo

In [6]:

df2.dtypes

Out[6]:

A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

In [11]:

df.describe()

Out[11]:

	A	B	C	D
count	6.000000	6.000000	6.000000	6.000000
mean	-0.228618	0.701427	0.096084	0.149506
std	1.131678	0.657413	1.229257	0.810483
min	-1.226727	-0.476202	-1.980305	-0.910752
25%	-1.098461	0.635757	-0.402617	-0.528577
50%	-0.476869	0.831620	0.457229	0.392131
75%	0.195279	0.902454	0.839783	0.771940
max	1.695086	1.524988	1.364281	0.960460

In [12]:

df.T

Out[12]:

	2013-01-01 00:00:00	2013-01-02 00:00:00	2013-01-03 00:00:00	2013-01-04 00:00:00	2013-01-05 00:00:00	2013-01-06 00:00:00
A	0.043660	0.245818	-0.997398	-1.132148	-1.226727	1.695086
B	0.914219	0.582317	-0.476202	0.867161	1.524988	0.796078
C	1.364281	0.456372	0.967015	0.458086	-1.980305	-0.688947
D	0.960460	-0.734680	0.089730	0.797743	0.694533	-0.910752

In [13]:

df.sort_index(axis=1, ascending=False)

Out[13]:

	D	C	B	A
2013-01-01	0.960460	1.364281	0.914219	0.043660
2013-01-02	-0.734680	0.456372	0.582317	0.245818
2013-01-03	0.089730	0.967015	-0.476202	-0.997398
2013-01-04	0.797743	0.458086	0.867161	-1.132148
2013-01-05	0.694533	-1.980305	1.524988	-1.226727
2013-01-06	-0.910752	-0.688947	0.796078	1.695086

In [14]:

df.sort_values(by='B')

Out[14]:

	A	B	C	D
2013-01-03	-0.997398	-0.476202	0.967015	0.089730
2013-01-02	0.245818	0.582317	0.456372	-0.734680
2013-01-06	1.695086	0.796078	-0.688947	-0.910752
2013-01-04	-1.132148	0.867161	0.458086	0.797743
2013-01-01	0.043660	0.914219	1.364281	0.960460
2013-01-05	-1.226727	1.524988	-1.980305	0.694533

In [15]:

df.apply(np.cumsum)

Out[15]:

	A	B	C	D
2013-01-01	0.043660	0.914219	1.364281	0.960460
2013-01-02	0.289478	1.496535	1.820653	0.225781
2013-01-03	-0.707920	1.020334	2.787668	0.315511
2013-01-04	-1.840068	1.887495	3.245754	1.113254
2013-01-05	-3.066794	3.412483	1.265449	1.807786
2013-01-06	-1.371708	4.208561	0.576502	0.897035

In [16]:

df.apply(lambda x: x.max() - x.min())

Out[16]:

A    2.921813
B    2.001190
C    3.344586
D    1.871212
dtype: float64

In [18]:

s = pd.Series(np.random.randint(0, 7, size=10))
s

Out[18]:

0    3
1    3
2    3
3    4
4    3
5    1
6    6
7    3
8    1
9    4
dtype: int32

In [19]:

s.value_counts()

Out[19]:

3    5
4    2
1    2
6    1
dtype: int64

In [20]:

s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s.str.lower()

Out[20]:

0       a
1       b
2       c
3    aaba
4    baca
5     NaN
6    caba
7     dog
8     cat
dtype: object

In [21]:

df = pd.DataFrame(np.random.randn(10, 4))
df

Out[21]:

	0	1	2	3
0	0.625507	-0.587885	0.933430	-1.608638
1	-0.570564	1.653211	-0.169102	0.278487
2	0.587255	0.580736	1.738137	-1.989709
3	1.238611	0.867963	-0.679791	1.784103
4	-0.190212	-1.065888	0.629625	0.968308
5	-1.123788	0.433555	0.613186	-0.885229
6	-0.872940	0.117758	1.085781	-1.739964
7	-1.064637	-1.562930	0.609092	0.591197
8	-0.479885	0.019224	-0.071010	0.203683
9	1.562199	-0.084385	0.169083	0.588641

In [24]:

pieces = [df[:3], df[3:7]]
pieces

Out[24]:

[          0         1         2         3
 0  0.625507 -0.587885  0.933430 -1.608638
 1 -0.570564  1.653211 -0.169102  0.278487
 2  0.587255  0.580736  1.738137 -1.989709,
           0         1         2         3
 3  1.238611  0.867963 -0.679791  1.784103
 4 -0.190212 -1.065888  0.629625  0.968308
 5 -1.123788  0.433555  0.613186 -0.885229
 6 -0.872940  0.117758  1.085781 -1.739964]

In [25]:

pd.concat(pieces)

Out[25]:

	0	1	2	3
0	0.625507	-0.587885	0.933430	-1.608638
1	-0.570564	1.653211	-0.169102	0.278487
2	0.587255	0.580736	1.738137	-1.989709
3	1.238611	0.867963	-0.679791	1.784103
4	-0.190212	-1.065888	0.629625	0.968308
5	-1.123788	0.433555	0.613186	-0.885229
6	-0.872940	0.117758	1.085781	-1.739964

In [26]:

left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})
left

Out[26]:

	key	lval
0	foo	1
1	foo	2

In [27]:

right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})
right

Out[27]:

	key	rval
0	foo	4
1	foo	5

In [28]:

pd.merge(left, right, on='key')

Out[28]:

	key	lval	rval
0	foo	1	4
1	foo	1	5
2	foo	2	4
3	foo	2	5

追加

In [29]:

df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])
df

Out[29]:

	A	B	C	D
0	0.567299	-0.835836	1.997388	1.219204
1	0.901536	-0.172666	-0.396798	1.102758
2	0.585077	-0.283219	0.685800	0.284514
3	0.228130	0.916432	0.102306	-1.420889
4	1.196156	-2.166493	1.202548	0.198905
5	0.930729	0.735202	0.780484	1.035269
6	0.335974	-0.364062	1.316474	-0.390350
7	1.611419	-0.277883	0.116712	-0.781101

In [30]:

s = df.iloc[3]
s

Out[30]:

A    0.228130
B    0.916432
C    0.102306
D   -1.420889
Name: 3, dtype: float64

In [31]:

df.append(s, ignore_index=True)

Out[31]:

	A	B	C	D
0	0.567299	-0.835836	1.997388	1.219204
1	0.901536	-0.172666	-0.396798	1.102758
2	0.585077	-0.283219	0.685800	0.284514
3	0.228130	0.916432	0.102306	-1.420889
4	1.196156	-2.166493	1.202548	0.198905
5	0.930729	0.735202	0.780484	1.035269
6	0.335974	-0.364062	1.316474	-0.390350
7	1.611419	-0.277883	0.116712	-0.781101
8	0.228130	0.916432	0.102306	-1.420889

分组

In [32]:

df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
                          'foo', 'bar', 'foo', 'foo'],
                   'B' : ['one', 'one', 'two', 'three',
                          'two', 'two', 'one', 'three'],
                   'C' : np.random.randn(8),
                   'D' : np.random.randn(8)})
df

Out[32]:

	A	B	C	D
0	foo	one	1.946394	-1.603756
1	bar	one	1.128497	0.186203
2	foo	two	0.768784	-1.485998
3	bar	three	1.530352	1.159454
4	foo	two	0.740245	-0.517180
5	bar	two	-1.475944	2.510523
6	foo	one	-0.822403	0.036043
7	foo	three	-0.799283	-2.370425

In [33]:

df.groupby('A').sum()

Out[33]:

	C	D
A
bar	1.182905	3.856180
foo	1.833737	-5.941317

In [34]:

df.groupby(['A','B']).sum()

Out[34]:

		C	D
A	B
bar	one	1.128497	0.186203
	three	1.530352	1.159454
	two	-1.475944	2.510523
foo	one	1.123991	-1.567713
	three	-0.799283	-2.370425
	two	1.509028	-2.003179

重塑

In [35]:

tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',
                 'foo', 'foo', 'qux', 'qux'],
                ['one', 'two', 'one', 'two',
                 'one', 'two', 'one', 'two']]))
tuples

Out[35]:

[('bar', 'one'),
 ('bar', 'two'),
 ('baz', 'one'),
 ('baz', 'two'),
 ('foo', 'one'),
 ('foo', 'two'),
 ('qux', 'one'),
 ('qux', 'two')]

In [36]:

index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
index

Out[36]:

MultiIndex(levels=[['bar', 'baz', 'foo', 'qux'], ['one', 'two']],
           labels=[[0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 0, 1, 0, 1, 0, 1]],
           names=['first', 'second'])

In [37]:

df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])
df

Out[37]:

		A	B
first	second
bar	one	-1.421775	0.156963
bar	two	1.564838	2.088619
baz	one	0.371071	0.103863
baz	two	-0.789093	0.952786
foo	one	1.931205	0.103578
foo	two	0.169767	-0.750791
qux	one	0.601066	-0.779490
qux	two	1.416660	1.744881

In [39]:

df2 = df[:4]
df2

Out[39]:

		A	B
first	second
bar	one	-1.421775	0.156963
bar	two	1.564838	2.088619
baz	one	0.371071	0.103863
baz	two	-0.789093	0.952786

In [40]:

stacked = df2.stack()
stacked

Out[40]:

first  second   
bar    one     A   -1.421775
               B    0.156963
       two     A    1.564838
               B    2.088619
baz    one     A    0.371071
               B    0.103863
       two     A   -0.789093
               B    0.952786
dtype: float64

In [41]:

stacked.unstack()

Out[41]:

		A	B
first	second
bar	one	-1.421775	0.156963
bar	two	1.564838	2.088619
baz	one	0.371071	0.103863
baz	two	-0.789093	0.952786

In [42]:

stacked.unstack(1)

Out[42]:

	second	one	two
first
bar	A	-1.421775	1.564838
bar	B	0.156963	2.088619
baz	A	0.371071	-0.789093
baz	B	0.103863	0.952786

In [43]:

stacked.unstack(0)

Out[43]:

	first	bar	baz
second
one	A	-1.421775	0.371071
one	B	0.156963	0.103863
two	A	1.564838	-0.789093
two	B	2.088619	0.952786

数据透视表

In [44]:

df = pd.DataFrame({'A' : ['one', 'one', 'two', 'three'] * 3,
                   'B' : ['A', 'B', 'C'] * 4,
                   'C' : ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,
                   'D' : np.random.randn(12),
                   'E' : np.random.randn(12)})
df

Out[44]:

	A	B	C	D	E
0	one	A	foo	1.955130	0.720242
1	one	B	foo	1.603413	1.022816
2	two	C	foo	-0.019881	-0.624567
3	three	A	bar	1.167609	-1.001875
4	one	B	bar	-0.468257	0.008671
5	one	C	bar	1.081470	1.286024
6	two	A	foo	-1.302491	0.751544
7	three	B	foo	1.139926	-0.791500
8	one	C	foo	-2.829628	0.850286
9	one	A	bar	-2.277605	-0.943648
10	two	B	bar	1.091066	-0.566744
11	three	C	bar	-1.175964	0.731061

In [45]:

pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])

Out[45]:

	C	bar	foo
A	B
one	A	-2.277605	1.955130
	B	-0.468257	1.603413
	C	1.081470	-2.829628
three	A	1.167609	NaN
	B	NaN	1.139926
	C	-1.175964	NaN
two	A	NaN	-1.302491
	B	1.091066	NaN
	C	NaN	-0.019881

时间序列

In [46]:

rng = pd.date_range('1/1/2012', periods=100, freq='S')
rng

Out[46]:

DatetimeIndex(['2012-01-01 00:00:00', '2012-01-01 00:00:01',
               '2012-01-01 00:00:02', '2012-01-01 00:00:03',
               '2012-01-01 00:00:04', '2012-01-01 00:00:05',
               '2012-01-01 00:00:06', '2012-01-01 00:00:07',
               '2012-01-01 00:00:08', '2012-01-01 00:00:09',
               '2012-01-01 00:00:10', '2012-01-01 00:00:11',
               '2012-01-01 00:00:12', '2012-01-01 00:00:13',
               '2012-01-01 00:00:14', '2012-01-01 00:00:15',
               '2012-01-01 00:00:16', '2012-01-01 00:00:17',
               '2012-01-01 00:00:18', '2012-01-01 00:00:19',
               '2012-01-01 00:00:20', '2012-01-01 00:00:21',
               '2012-01-01 00:00:22', '2012-01-01 00:00:23',
               '2012-01-01 00:00:24', '2012-01-01 00:00:25',
               '2012-01-01 00:00:26', '2012-01-01 00:00:27',
               '2012-01-01 00:00:28', '2012-01-01 00:00:29',
               '2012-01-01 00:00:30', '2012-01-01 00:00:31',
               '2012-01-01 00:00:32', '2012-01-01 00:00:33',
               '2012-01-01 00:00:34', '2012-01-01 00:00:35',
               '2012-01-01 00:00:36', '2012-01-01 00:00:37',
               '2012-01-01 00:00:38', '2012-01-01 00:00:39',
               '2012-01-01 00:00:40', '2012-01-01 00:00:41',
               '2012-01-01 00:00:42', '2012-01-01 00:00:43',
               '2012-01-01 00:00:44', '2012-01-01 00:00:45',
               '2012-01-01 00:00:46', '2012-01-01 00:00:47',
               '2012-01-01 00:00:48', '2012-01-01 00:00:49',
               '2012-01-01 00:00:50', '2012-01-01 00:00:51',
               '2012-01-01 00:00:52', '2012-01-01 00:00:53',
               '2012-01-01 00:00:54', '2012-01-01 00:00:55',
               '2012-01-01 00:00:56', '2012-01-01 00:00:57',
               '2012-01-01 00:00:58', '2012-01-01 00:00:59',
               '2012-01-01 00:01:00', '2012-01-01 00:01:01',
               '2012-01-01 00:01:02', '2012-01-01 00:01:03',
               '2012-01-01 00:01:04', '2012-01-01 00:01:05',
               '2012-01-01 00:01:06', '2012-01-01 00:01:07',
               '2012-01-01 00:01:08', '2012-01-01 00:01:09',
               '2012-01-01 00:01:10', '2012-01-01 00:01:11',
               '2012-01-01 00:01:12', '2012-01-01 00:01:13',
               '2012-01-01 00:01:14', '2012-01-01 00:01:15',
               '2012-01-01 00:01:16', '2012-01-01 00:01:17',
               '2012-01-01 00:01:18', '2012-01-01 00:01:19',
               '2012-01-01 00:01:20', '2012-01-01 00:01:21',
               '2012-01-01 00:01:22', '2012-01-01 00:01:23',
               '2012-01-01 00:01:24', '2012-01-01 00:01:25',
               '2012-01-01 00:01:26', '2012-01-01 00:01:27',
               '2012-01-01 00:01:28', '2012-01-01 00:01:29',
               '2012-01-01 00:01:30', '2012-01-01 00:01:31',
               '2012-01-01 00:01:32', '2012-01-01 00:01:33',
               '2012-01-01 00:01:34', '2012-01-01 00:01:35',
               '2012-01-01 00:01:36', '2012-01-01 00:01:37',
               '2012-01-01 00:01:38', '2012-01-01 00:01:39'],
              dtype='datetime64[ns]', freq='S')

In [48]:

ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
ts

Out[48]:

2012-01-01 00:00:00    478
2012-01-01 00:00:01    350
2012-01-01 00:00:02     17
2012-01-01 00:00:03    439
2012-01-01 00:00:04     84
2012-01-01 00:00:05    164
2012-01-01 00:00:06     17
2012-01-01 00:00:07    182
2012-01-01 00:00:08    482
2012-01-01 00:00:09    198
2012-01-01 00:00:10    231
2012-01-01 00:00:11    446
2012-01-01 00:00:12    271
2012-01-01 00:00:13    453
2012-01-01 00:00:14    418
2012-01-01 00:00:15    235
2012-01-01 00:00:16    231
2012-01-01 00:00:17     95
2012-01-01 00:00:18    132
2012-01-01 00:00:19    364
2012-01-01 00:00:20     93
2012-01-01 00:00:21    225
2012-01-01 00:00:22    255
2012-01-01 00:00:23    120
2012-01-01 00:00:24    387
2012-01-01 00:00:25    175
2012-01-01 00:00:26    174
2012-01-01 00:00:27    426
2012-01-01 00:00:28    185
2012-01-01 00:00:29     44
                      ... 
2012-01-01 00:01:10     61
2012-01-01 00:01:11      3
2012-01-01 00:01:12     14
2012-01-01 00:01:13    342
2012-01-01 00:01:14    361
2012-01-01 00:01:15    394
2012-01-01 00:01:16    414
2012-01-01 00:01:17    452
2012-01-01 00:01:18    191
2012-01-01 00:01:19    297
2012-01-01 00:01:20     16
2012-01-01 00:01:21    481
2012-01-01 00:01:22    364
2012-01-01 00:01:23     73
2012-01-01 00:01:24    238
2012-01-01 00:01:25    331
2012-01-01 00:01:26    111
2012-01-01 00:01:27    347
2012-01-01 00:01:28     28
2012-01-01 00:01:29    276
2012-01-01 00:01:30     33
2012-01-01 00:01:31    315
2012-01-01 00:01:32    177
2012-01-01 00:01:33     39
2012-01-01 00:01:34    211
2012-01-01 00:01:35    214
2012-01-01 00:01:36     65
2012-01-01 00:01:37    151
2012-01-01 00:01:38    418
2012-01-01 00:01:39    256
Freq: S, Length: 100, dtype: int32

In [49]:

ts.resample('5Min').sum()

Out[49]:

2012-01-01    25315
Freq: 5T, dtype: int32

In [50]:

rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')
ts = pd.Series(np.random.randn(len(rng)), rng)
ts

Out[50]:

2012-03-06   -0.844716
2012-03-07   -0.354952
2012-03-08    0.847330
2012-03-09    0.199636
2012-03-10   -0.157474
Freq: D, dtype: float64

In [51]:

ts_utc = ts.tz_localize('UTC')
ts_utc

Out[51]:

2012-03-06 00:00:00+00:00   -0.844716
2012-03-07 00:00:00+00:00   -0.354952
2012-03-08 00:00:00+00:00    0.847330
2012-03-09 00:00:00+00:00    0.199636
2012-03-10 00:00:00+00:00   -0.157474
Freq: D, dtype: float64

转换为另一个时区：

In [52]:

ts_utc.tz_convert('US/Eastern')

Out[52]:

2012-03-05 19:00:00-05:00   -0.844716
2012-03-06 19:00:00-05:00   -0.354952
2012-03-07 19:00:00-05:00    0.847330
2012-03-08 19:00:00-05:00    0.199636
2012-03-09 19:00:00-05:00   -0.157474
Freq: D, dtype: float64

在时间跨度表示之间转换：

In [53]:

rng = pd.date_range('1/1/2012', periods=5, freq='M')
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts

Out[53]:

2012-01-31   -0.081224
2012-02-29    1.507458
2012-03-31    0.892793
2012-04-30   -1.667747
2012-05-31    1.100369
Freq: M, dtype: float64

In [55]:

ps = ts.to_period()
ps

Out[55]:

2012-01   -0.081224
2012-02    1.507458
2012-03    0.892793
2012-04   -1.667747
2012-05    1.100369
Freq: M, dtype: float64

In [56]:

ps.to_timestamp()

Out[56]:

2012-01-01   -0.081224
2012-02-01    1.507458
2012-03-01    0.892793
2012-04-01   -1.667747
2012-05-01    1.100369
Freq: MS, dtype: float64

In [57]:

prng = pd.period_range('1990Q1', '2000Q4', freq='Q-NOV')
prng

Out[57]:

PeriodIndex(['1990Q1', '1990Q2', '1990Q3', '1990Q4', '1991Q1', '1991Q2',
             '1991Q3', '1991Q4', '1992Q1', '1992Q2', '1992Q3', '1992Q4',
             '1993Q1', '1993Q2', '1993Q3', '1993Q4', '1994Q1', '1994Q2',
             '1994Q3', '1994Q4', '1995Q1', '1995Q2', '1995Q3', '1995Q4',
             '1996Q1', '1996Q2', '1996Q3', '1996Q4', '1997Q1', '1997Q2',
             '1997Q3', '1997Q4', '1998Q1', '1998Q2', '1998Q3', '1998Q4',
             '1999Q1', '1999Q2', '1999Q3', '1999Q4', '2000Q1', '2000Q2',
             '2000Q3', '2000Q4'],
            dtype='period[Q-NOV]', freq='Q-NOV')

In [58]:

ts = pd.Series(np.random.randn(len(prng)), prng)
ts

Out[58]:

1990Q1    1.115171
1990Q2   -0.910567
1990Q3    0.572898
1990Q4    0.122395
1991Q1   -0.742167
1991Q2   -0.249733
1991Q3    0.008649
1991Q4    0.922641
1992Q1   -0.377793
1992Q2   -0.810604
1992Q3    1.347122
1992Q4   -1.089756
1993Q1    0.921470
1993Q2   -0.315505
1993Q3    0.054035
1993Q4    0.196308
1994Q1    0.158628
1994Q2   -1.547737
1994Q3    0.805891
1994Q4   -2.249038
1995Q1    2.174847
1995Q2   -1.205269
1995Q3   -0.251231
1995Q4   -0.810176
1996Q1   -0.044167
1996Q2    0.893497
1996Q3    1.552094
1996Q4   -0.612805
1997Q1    0.918409
1997Q2    0.980157
1997Q3    1.509811
1997Q4    0.059969
1998Q1   -0.359608
1998Q2    1.643402
1998Q3    1.616181
1998Q4    1.882245
1999Q1    0.128783
1999Q2   -0.391579
1999Q3    1.448685
1999Q4    1.829124
2000Q1    1.583030
2000Q2   -1.449266
2000Q3   -0.153701
2000Q4    0.726885
Freq: Q-NOV, dtype: float64

In [61]:

ts.index = (prng.asfreq('M', 'e') + 1).asfreq('H', 's') + 9
ts.head()

Out[61]:

1990-03-01 09:00    1.115171
1990-06-01 09:00   -0.910567
1990-09-01 09:00    0.572898
1990-12-01 09:00    0.122395
1991-03-01 09:00   -0.742167
Freq: H, dtype: float64

分类

In [63]:

df = pd.DataFrame({"id":[1,2,3,4,5,6], "raw_grade":['a', 'b', 'b', 'a', 'a', 'e']})
df

Out[63]:

	id	raw_grade
0	1	a
1	2	b
2	3	b
3	4	a
4	5	a
5	6	e

In [67]:

df["grade"] = df["raw_grade"].astype("category")
df["grade"]

Out[67]:

0    a
1    b
2    b
3    a
4    a
5    e
Name: grade, dtype: category
Categories (3, object): [a, b, e]

In [66]:

df

Out[66]:

	id	raw_grade	grade
0	1	a	a
1	2	b	b
2	3	b	b
3	4	a	a
4	5	a	a
5	6	e	e

In [68]:

df["grade"].cat.categories = ["very good", "good", "very bad"]
df["grade"]

Out[68]:

0    very good
1         good
2         good
3    very good
4    very good
5     very bad
Name: grade, dtype: category
Categories (3, object): [very good, good, very bad]

In [69]:

df["grade"] = df["grade"].cat.set_categories(["very bad", "bad", "medium", "good", "very good"])
df["grade"]

Out[69]:

0    very good
1         good
2         good
3    very good
4    very good
5     very bad
Name: grade, dtype: category
Categories (5, object): [very bad, bad, medium, good, very good]

In [70]:

df

Out[70]:

	id	raw_grade	grade
0	1	a	very good
1	2	b	good
2	3	b	good
3	4	a	very good
4	5	a	very good
5	6	e	very bad

In [71]:

df.groupby("grade").size()

Out[71]:

grade
very bad     1
bad          0
medium       0
good         2
very good    3
dtype: int64

绘图

In [81]:

%matplotlib  inline

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

Out[81]:

In [93]:

import matplotlib.pyplot as plt

df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,
                  columns=['A', 'B', 'C', 'D'])
df = df.cumsum()
plt.figure(); df.plot(); plt.legend(loc='best')

Out[93]:

获取数据进/出

In [94]:

'''
df.to_csv('foo.csv')
pd.read_csv('foo.csv')

df.to_hdf('foo.h5','df')
pd.read_hdf('foo.h5','df')

df.to_excel('foo.xlsx', sheet_name='Sheet1')
pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])
'''

Out[94]:

"\ndf.to_csv('foo.csv')\npd.read_csv('foo.csv')\n\ndf.to_hdf('foo.h5','df')\npd.read_hdf('foo.h5','df')\n\ndf.to_excel('foo.xlsx', sheet_name='Sheet1')\npd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])\n"

你可能感兴趣的:(入门,--,Python与数据科学)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
2021-08-26 影幽
在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
水泥质量纠纷案代理词徐宝峰律师
贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
18-115 一切思考不能有效转化为行动，都TM是扯淡！成长时间线
7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
山东大学小树林支教调研团青青仓木队——翟晓楠山东大学青青仓木队
过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
直返最高等级与直返APP：无需邀请码的返利新体验古楼
随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
面向对象面向过程 3213213333332132 java
面向对象：把要完成的一件事，通过对象间的协作实现。面向过程：把要完成的一件事，通过循序依次调用各个模块实现。我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122 JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
BaseDao 171815164 seda
import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
Ant标签详解--Java命令 g21121 Java命令
这一篇主要介绍与java相关标签的使用终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。 1
[简单]代码片段_电梯数字排列 53873039oycg 代码
今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下: import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
Hessian原理云端月影 hessian原理
Hessian 原理分析一．远程通讯协议的基本原理网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
区分Activity的四种加载模式----以及Intent的setFlags aijuans android
在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
hibernate几个核心API及其查询分析 antonyup_2006 html .net Hibernate xml 配置管理
(一) org.hibernate.cfg.Configuration类读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.) Configuration co
PL/SQL的流程控制百合不是茶 oracle PL/SQL编程循环控制
PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
强大的Mockito测试框架 bijian1013 mockito 单元测试
一.自动生成Mock类在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类 &nbs
精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle 数据库 plsql
/* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
【EhCache一】EhCache版Hello World bit1129 Hello world
本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍环境准备 1.新建Maven项目 2.添加EhCache的Maven依赖 <dependency> <groupId>ne
学习EJB3基础知识笔记白糖_ bean Hibernate jboss webservice ejb
最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。 EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
angular.bootstrap boyitech AngularJS AngularJS API angular中文api
angular.bootstrap 描述：手动初始化angular。这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。使用方法： angular .
java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！自己挑了两部先看了看，但是发现看完之后，心里久久不能平
[机器智能与生物]研究生物智能的问题 comsci 生物
我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别.... 但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
获取Android Device的信息 dai_lm android
String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java 算法字符串匹配
原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
小学5年级英语单词背诵第一课 dcj3sjt126com english word
long 长的 show 给...看，出示 mouth 口，嘴 write 写 use 用，使用 take 拿，带来 hand 手 clever 聪明的 often 经常 wash 洗 slow 慢的 house 房子 water 水 clean 清洁的 supper 晚餐 out 在外 face 脸，
macvim的使用实战 dcj3sjt126com mac vim
macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳 1. 下载macvim https://code.google.com/p/macvim/ 2. 了解macvim :h vim的使用帮助信息 :h macvim
java二分法查找蕃薯耀 java二分法查找二分法 java二分法
java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
Spring Cache注解+Memcached hanqunfeng spring memcached
Spring3.1 Cache注解依赖jar包：  <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
apache commons io包快速入门 jackyrong apache commons
原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍： 1）工具类 2
如何学习编程 lampcy java 编程 C++c
首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
1.前言。如题。 2.描述。 @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
Spring4+quartz2的配置和代码方式调度 Everyday都不同代码配置 spring4 quartz2.x 定时任务
前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API…… quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
Hibernate入门 tntxia Hibernate
前言使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。 Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。如
Math类 xiaoxing598 Math
一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round