狮子HH

10分钟入门pandas

本文是对pandas的一个入门介绍，仅仅针对初学者。如果需要更详细的内容，请移步[Cookbook](http://pandas.pydata.org/pandas-docs/stable/cookbook.html#cookbook). 首先，导入所需要的python包：

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

创建对象 ———– pandas中的数据结构包括Series、DataFrame、Panel、Pannel4D等，详细介绍移步[数据结构介绍](http://pandas.pydata.org/pandas-docs/stable/dsintro.html#dsintro). 常用的数据结构是前两个：Series和DataFrame。通过传入一个已有的python列表（list）对象来创建一个Series对象。

s = pd.Series([1,3,4,np.nan,6,8])

0 1.0 1 3.0 2 4.0 3 NaN 4 6.0 5 8.0 dtype: float64 通过传入一个numpy数组来构建一个DataFrame对象。使用时间序列作为每行的索引，并为每列数据分配一个列名。

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

dates

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

# 创建DataFrame对象，并指定索引index和列名columns
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

df

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197

通过传入一个python字典对象来创建一个DataFrame对象。

df2 = pd.DataFrame({'A': 1.,
                    'B': pd.Timestamp('20160102'),
                    '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

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

# DataFrame 中每列的数据类型可以不同
df2.dtypes

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

在ipython中可以使用“Tab”键对DataFrame的列名和公共属性进行自动补全。

查看对象中的数据

查看DataFrame的前几行或最后几行

df.head()

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950

df.tail()

	A	B	C	D
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197

df.head(3)

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457

获取DataFrame的索引、列名、数据（值）。

df.index

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

df.columns

Index([u'A', u'B', u'C', u'D'], dtype='object')

df.values

array([[-0.28589413,  0.49001051,  0.17112101, -1.54980655],
       [-0.06837701, -0.45280422, -0.39189213, -0.85252018],
       [ 1.30438846, -1.80848416, -0.28648908, -0.43745725],
       [ 1.44781215, -1.86212061,  0.11594994, -0.66413402],
       [ 0.5204089 , -1.4027399 , -0.35604882,  0.4609499 ],
       [-0.40489995,  0.58541997, -0.07392295, -0.5011969 ]])

使用“describe”获取数据的统计信息。

df.describe()

	A	B	C	D
count	6.000000	6.000000	6.000000	6.000000
mean	0.418906	-0.741786	-0.136880	-0.590694
std	0.808192	1.112849	0.244213	0.652884
min	-0.404900	-1.862121	-0.391892	-1.549807
25%	-0.231515	-1.707048	-0.338659	-0.805424
50%	0.226016	-0.927772	-0.180206	-0.582665
75%	1.108394	0.254307	0.068482	-0.453392
max	1.447812	0.585420	0.171121	0.460950

将DataFrame进行转置。

df.T

	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.285894	-0.068377	1.304388	1.447812	0.520409	-0.404900
B	0.490011	-0.452804	-1.808484	-1.862121	-1.402740	0.585420
C	0.171121	-0.391892	-0.286489	0.115950	-0.356049	-0.073923
D	-1.549807	-0.852520	-0.437457	-0.664134	0.460950	-0.501197

df

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197

对坐标轴进行排序。

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

	D	C	B	A
2013-01-01	-1.549807	0.171121	0.490011	-0.285894
2013-01-02	-0.852520	-0.391892	-0.452804	-0.068377
2013-01-03	-0.437457	-0.286489	-1.808484	1.304388
2013-01-04	-0.664134	0.115950	-1.862121	1.447812
2013-01-05	0.460950	-0.356049	-1.402740	0.520409
2013-01-06	-0.501197	-0.073923	0.585420	-0.404900

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

	A	B	C	D
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-01	-0.285894	0.490011	0.171121	-1.549807

对值进行排序。

df.sort_values(by='B')

	A	B	C	D
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197

df.sort_values(by='B',ascending=False)

	A	B	C	D
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134

选择数据

pandas中对数据的选择可以使用标准的python/numpy方式。

df['A']

2013-01-01   -0.285894
2013-01-02   -0.068377
2013-01-03    1.304388
2013-01-04    1.447812
2013-01-05    0.520409
2013-01-06   -0.404900
Freq: D, Name: A, dtype: float64

# 选择一个单独的列，将产生一个Series，此时df['A']等价于df.A
df.A

2013-01-01   -0.285894
2013-01-02   -0.068377
2013-01-03    1.304388
2013-01-04    1.447812
2013-01-05    0.520409
2013-01-06   -0.404900
Freq: D, Name: A, dtype: float64

对行进行切片操作。

df[0:3]

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457

df['20130103':'20130105']

	A	B	C	D
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950

使用标准的python/numpy方法获取数据的方式很直观，但是对于工业级的代码，建议使用优化的pandas数据获取方法，包括：.at,.iat,.iloc和.ix

df

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197

dates

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

df.loc[dates[0]]

A   -0.285894
B    0.490011
C    0.171121
D   -1.549807
Name: 2013-01-01 00:00:00, dtype: float64

按类标选择多坐标轴的数据。

df.loc[:,['A','B']]

	A	B
2013-01-01	-0.285894	0.490011
2013-01-02	-0.068377	-0.452804
2013-01-03	1.304388	-1.808484
2013-01-04	1.447812	-1.862121
2013-01-05	0.520409	-1.402740
2013-01-06	-0.404900	0.585420

# 在对数据进行切片操作时，两端都会包含，不像python中只含前端不含后端
df.loc['20130102':'20130104',['A','B']]

	A	B
2013-01-02	-0.068377	-0.452804
2013-01-03	1.304388	-1.808484
2013-01-04	1.447812	-1.862121

# 当只有一维的时候，返回的数据维数会自动缩减
df.loc['20130105',['A','B']]

A    0.520409
B   -1.402740
Name: 2013-01-05 00:00:00, dtype: float64

df.loc['20130105','A']

0.52040890430486719

# 相对于.loc,.at是一种更快地获取一个标量数据的方法
df.at[dates[0],'A']

-0.28589413005579967

按位置进行选择，传入整数，返回数据。

df

	A	B	C	D
2013-01-01	-0.285894	0.490011	0.171121	-1.549807
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197

df.iloc[3]

A    1.447812
B   -1.862121
C    0.115950
D   -0.664134
Name: 2013-01-04 00:00:00, dtype: float64

df.iloc[3:5,0:2]

	A	B
2013-01-04	1.447812	-1.862121
2013-01-05	0.520409	-1.402740

按整数位置进行数据选取或切片时，方法同python/numpy，从0开始索引，包含前端不含后端。

df.iloc[[1,2,4],[0,2]]

	A	C
2013-01-02	-0.068377	-0.391892
2013-01-03	1.304388	-0.286489
2013-01-05	0.520409	-0.356049

# 对行进行切片
df.iloc[1:3,:]

	A	B	C	D
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457

# 对列进行切片
df.iloc[:,1:3]

	B	C
2013-01-01	0.490011	0.171121
2013-01-02	-0.452804	-0.391892
2013-01-03	-1.808484	-0.286489
2013-01-04	-1.862121	0.115950
2013-01-05	-1.402740	-0.356049
2013-01-06	0.585420	-0.073923

df.iloc[1,1]

-0.45280421688689004

# .iat 比 .iloc 具有更快的速度
df.iat[1,1]

-0.45280421688689004

使用布尔值进行索引。

df[df.A > 0]

	A	B	C	D
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457
2013-01-04	1.447812	-1.862121	0.115950	-0.664134
2013-01-05	0.520409	-1.402740	-0.356049	0.460950

df[df > 0]

	A	B	C	D
2013-01-01	NaN	0.490011	0.171121	NaN
2013-01-02	NaN	NaN	NaN	NaN
2013-01-03	1.304388	NaN	NaN	NaN
2013-01-04	1.447812	NaN	0.115950	NaN
2013-01-05	0.520409	NaN	NaN	0.46095
2013-01-06	NaN	0.585420	NaN	NaN

使用isin()方法进行过滤。

df2 = df.copy()

df2['E'] = ['one','one','two','three','four','three']

df2

	A	B	C	D	E
2013-01-01	-0.285894	0.490011	0.171121	-1.549807	one
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520	one
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457	two
2013-01-04	1.447812	-1.862121	0.115950	-0.664134	three
2013-01-05	0.520409	-1.402740	-0.356049	0.460950	four
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197	three

df2[df2['E'].isin(['one','four'])]

	A	B	C	D	E
2013-01-01	-0.285894	0.490011	0.171121	-1.549807	one
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520	one
2013-01-05	0.520409	-1.402740	-0.356049	0.460950	four

设置数据

设置一个新列，自动按索引分配数据。

s1 = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102',periods=6))

s1

2013-01-02    1
2013-01-03    2
2013-01-04    3
2013-01-05    4
2013-01-06    5
2013-01-07    6
Freq: D, dtype: int64

df['F'] = s1

df

	A	B	C	D	F
2013-01-01	-0.285894	0.490011	0.171121	-1.549807	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520	1.0
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457	2.0
2013-01-04	1.447812	-1.862121	0.115950	-0.664134	3.0
2013-01-05	0.520409	-1.402740	-0.356049	0.460950	4.0
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197	5.0

因为s1是从‘20130102’开始的，所以‘20130101’对应的F列值为‘NaN’

df.at[dates[0],'A'] = 0

df

	A	B	C	D	F
2013-01-01	0.000000	0.490011	0.171121	-1.549807	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	-0.852520	1.0
2013-01-03	1.304388	-1.808484	-0.286489	-0.437457	2.0
2013-01-04	1.447812	-1.862121	0.115950	-0.664134	3.0
2013-01-05	0.520409	-1.402740	-0.356049	0.460950	4.0
2013-01-06	-0.404900	0.585420	-0.073923	-0.501197	5.0

df.iat[0,1] = 0

df.loc[:,'D'] = np.array([5] * len(df))

df

	A	B	C	D	F
2013-01-01	0.000000	0.000000	0.171121	5	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0
2013-01-04	1.447812	-1.862121	0.115950	5	3.0
2013-01-05	0.520409	-1.402740	-0.356049	5	4.0
2013-01-06	-0.404900	0.585420	-0.073923	5	5.0

df2 = df.copy()

df2[df2 > 0] = -df2

df2

	A	B	C	D	F
2013-01-01	0.000000	0.000000	-0.171121	-5	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	-5	-1.0
2013-01-03	-1.304388	-1.808484	-0.286489	-5	-2.0
2013-01-04	-1.447812	-1.862121	-0.115950	-5	-3.0
2013-01-05	-0.520409	-1.402740	-0.356049	-5	-4.0
2013-01-06	-0.404900	-0.585420	-0.073923	-5	-5.0

缺失数据

pandas主要使用”np.nan“表示缺失数据，默认是不参与计算的。
“reindex”使我们可以对某个轴上的索引进行增删改操作。这种操作返回的是数据的一个备份。

df1 = df.reindex(index=dates[0:4], columns=list(df.columns)+['E'])

df1.loc[dates[0]:dates[1],'E'] = 1

df1

	A	B	C	D	F	E
2013-01-01	0.000000	0.000000	0.171121	5	NaN	1.0
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0	NaN
2013-01-04	1.447812	-1.862121	0.115950	5	3.0	NaN

# 将含有缺失数据的行全部去掉
df1.dropna(how='any')

	A	B	C	D	F	E
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0	1.0

# 对缺失数据进行填补
df1.fillna(value=5)

	A	B	C	D	F	E
2013-01-01	0.000000	0.000000	0.171121	5	5.0	1.0
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0	5.0
2013-01-04	1.447812	-1.862121	0.115950	5	3.0	5.0

# 获得缺失值的布尔mask
pd.isnull(df1)

	A	B	C	D	F	E
2013-01-01	False	False	False	False	True	False
2013-01-02	False	False	False	False	False	False
2013-01-03	False	False	False	False	False	True
2013-01-04	False	False	False	False	False	True

df1

	A	B	C	D	F	E
2013-01-01	0.000000	0.000000	0.171121	5	NaN	1.0
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0	NaN
2013-01-04	1.447812	-1.862121	0.115950	5	3.0	NaN

运算

运算通常不含缺失值。

# 统计运算
df

	A	B	C	D	F
2013-01-01	0.000000	0.000000	0.171121	5	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0
2013-01-04	1.447812	-1.862121	0.115950	5	3.0
2013-01-05	0.520409	-1.402740	-0.356049	5	4.0
2013-01-06	-0.404900	0.585420	-0.073923	5	5.0

df.mean()

A    0.466555
B   -0.823455
C   -0.136880
D    5.000000
F    3.000000
dtype: float64

df.mean(1)

2013-01-01    1.292780
2013-01-02    1.017385
2013-01-03    1.241883
2013-01-04    1.540328
2013-01-05    1.552324
2013-01-06    2.021319
Freq: D, dtype: float64

在具有不同维度的对象之间进行运算时，需要进行对其。pandas会自动沿着特定维度进行扩展操作。

s = pd.Series([1,3,5,np.nan,6,8], index=dates)

2013-01-01    1.0
2013-01-02    3.0
2013-01-03    5.0
2013-01-04    NaN
2013-01-05    6.0
2013-01-06    8.0
Freq: D, dtype: float64

s = s.shift(2)

2013-01-01    NaN
2013-01-02    NaN
2013-01-03    1.0
2013-01-04    3.0
2013-01-05    5.0
2013-01-06    NaN
Freq: D, dtype: float64

df

	A	B	C	D	F
2013-01-01	0.000000	0.000000	0.171121	5	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0
2013-01-04	1.447812	-1.862121	0.115950	5	3.0
2013-01-05	0.520409	-1.402740	-0.356049	5	4.0
2013-01-06	-0.404900	0.585420	-0.073923	5	5.0

df.sub(s,axis='index')

	A	B	C	D	F
2013-01-01	NaN	NaN	NaN	NaN	NaN
2013-01-02	NaN	NaN	NaN	NaN	NaN
2013-01-03	0.304388	-2.808484	-1.286489	4.0	1.0
2013-01-04	-1.552188	-4.862121	-2.884050	2.0	0.0
2013-01-05	-4.479591	-6.402740	-5.356049	0.0	-1.0
2013-01-06	NaN	NaN	NaN	NaN	NaN

sub()是减运算，df减去s时s的维度会自动进行扩展。

apply运算
apply运算将函数作用于数据。

df.apply(np.cumsum)

	A	B	C	D	F
2013-01-01	0.000000	0.000000	0.171121	5	NaN
2013-01-02	-0.068377	-0.452804	-0.220771	10	1.0
2013-01-03	1.236011	-2.261288	-0.507260	15	3.0
2013-01-04	2.683824	-4.123409	-0.391310	20	6.0
2013-01-05	3.204233	-5.526149	-0.747359	25	10.0
2013-01-06	2.799333	-4.940729	-0.821282	30	15.0

df

	A	B	C	D	F
2013-01-01	0.000000	0.000000	0.171121	5	NaN
2013-01-02	-0.068377	-0.452804	-0.391892	5	1.0
2013-01-03	1.304388	-1.808484	-0.286489	5	2.0
2013-01-04	1.447812	-1.862121	0.115950	5	3.0
2013-01-05	0.520409	-1.402740	-0.356049	5	4.0
2013-01-06	-0.404900	0.585420	-0.073923	5	5.0

np.cumsum是求元素累加和，上述操作将每行数据依次累加到下一行上。

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

A    1.852712
B    2.447541
C    0.563013
D    0.000000
F    4.000000
dtype: float64

柱状图
统计每个数据出现的次数。

# 随机生成0~7之间的10个整数
s = pd.Series(np.random.randint(0,7,size=10))

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

s.value_counts()

5    3
6    2
1    2
4    1
3    1
0    1
dtype: int64

字符串方法

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

s.str.lower()

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

数据融合

pandas提供了多种工具可以将Series、DataFrame和Panel对象按照多种逻辑结合起来。

使用concat()连接pandas对象

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

df

	0	1	2	3
0	0.526889	2.038465	-0.564220	0.263579
1	-0.987904	-0.306195	1.805246	0.030639
2	1.288416	-0.514634	0.450702	0.671194
3	0.209680	-0.868604	0.553508	0.173013
4	-0.443213	-0.998113	-0.237519	-0.401295
5	0.595207	0.845315	-0.914725	1.471180
6	-0.539326	-0.681776	0.491664	2.022497
7	1.083012	0.518738	0.707878	-0.337114
8	-1.322083	0.495178	-0.223462	-1.511751
9	-0.105515	-0.256568	1.591926	0.755486

# 将df切成片
pieces = [df[:3], df[3:7], df[7:]]

pieces

[          0         1         2         3
 0  0.526889  2.038465 -0.564220  0.263579
 1 -0.987904 -0.306195  1.805246  0.030639
 2  1.288416 -0.514634  0.450702  0.671194,
           0         1         2         3
 3  0.209680 -0.868604  0.553508  0.173013
 4 -0.443213 -0.998113 -0.237519 -0.401295
 5  0.595207  0.845315 -0.914725  1.471180
 6 -0.539326 -0.681776  0.491664  2.022497,
           0         1         2         3
 7  1.083012  0.518738  0.707878 -0.337114
 8 -1.322083  0.495178 -0.223462 -1.511751
 9 -0.105515 -0.256568  1.591926  0.755486]

pd.concat(pieces)

	0	1	2	3
0	0.526889	2.038465	-0.564220	0.263579
1	-0.987904	-0.306195	1.805246	0.030639
2	1.288416	-0.514634	0.450702	0.671194
3	0.209680	-0.868604	0.553508	0.173013
4	-0.443213	-0.998113	-0.237519	-0.401295
5	0.595207	0.845315	-0.914725	1.471180
6	-0.539326	-0.681776	0.491664	2.022497
7	1.083012	0.518738	0.707878	-0.337114
8	-1.322083	0.495178	-0.223462	-1.511751
9	-0.105515	-0.256568	1.591926	0.755486

join
SQL风格的数据融合。

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

left

	key	lval
0	foo	1
1	foo	2

right

	key	rval
0	foo	4
1	foo	5

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

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

append
为dataframe增加行。

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

df

	A	B	C	D
0	-0.346194	-1.878628	0.257169	0.445530
1	1.098394	-1.127943	-1.251522	-0.653498
2	1.296878	-0.757345	-2.423548	-2.233024
3	0.857649	-0.320409	0.267631	-1.337814
4	0.090567	1.460739	0.212409	-0.308281
5	0.951721	1.305034	0.721996	0.669566
6	0.104395	1.904366	-0.132059	0.436476
7	0.552328	-1.344539	0.459006	1.713434

s = df.iloc[3]

df.append(s, ignore_index=True)

	A	B	C	D
0	-0.346194	-1.878628	0.257169	0.445530
1	1.098394	-1.127943	-1.251522	-0.653498
2	1.296878	-0.757345	-2.423548	-2.233024
3	0.857649	-0.320409	0.267631	-1.337814
4	0.090567	1.460739	0.212409	-0.308281
5	0.951721	1.305034	0.721996	0.669566
6	0.104395	1.904366	-0.132059	0.436476
7	0.552328	-1.344539	0.459006	1.713434
8	0.857649	-0.320409	0.267631	-1.337814

分组

“group by” 表示以下步骤中的一步或多步操作。
- 将数据按照某些标准分为多组
- 对每个组进行一个函数运算
- 将结果结合成一个数据结构

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

	A	B	C	D
0	foo	one	0.460761	-0.001011
1	bar	one	2.001010	0.282712
2	foo	two	-1.171306	-0.085701
3	bar	three	0.723922	1.013934
4	foo	two	0.566774	-0.654899
5	bar	two	0.653483	1.013699
6	foo	one	0.072918	-0.590657
7	foo	three	-0.161579	-0.485670

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

	C	D
A
bar	3.378415	2.310345
foo	-0.232432	-1.817937

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

		C	D
A	B
bar	one	2.001010	0.282712
	three	0.723922	1.013934
	two	0.653483	1.013699
foo	one	0.533679	-0.591667
	three	-0.161579	-0.485670
	two	-0.604532	-0.740600

Reshaping

stack

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

tuples

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

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

index

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

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

df

		A	B
first	second
bar	one	0.055334	0.953745
bar	two	1.719361	0.419879
baz	one	0.180238	0.844578
baz	two	0.233350	-1.366278
foo	one	-0.285023	-0.353144
foo	two	-1.531769	-0.146243
qux	one	-0.419270	0.308597
qux	two	0.763019	0.631118

df2 = df[:4]

df2

		A	B
first	second
bar	one	0.055334	0.953745
bar	two	1.719361	0.419879
baz	one	0.180238	0.844578
baz	two	0.233350	-1.366278

stacked = df2.stack()

stacked

first  second   
bar    one     A    0.055334
               B    0.953745
       two     A    1.719361
               B    0.419879
baz    one     A    0.180238
               B    0.844578
       two     A    0.233350
               B   -1.366278
dtype: float64

stack()方法将DataFrame的列压缩了一个级别

对于一个以MultiIndex为索引的stacked DataFrame或Series,stack()的逆操作是unstack().

stacked.unstack()

		A	B
first	second
bar	one	0.055334	0.953745
bar	two	1.719361	0.419879
baz	one	0.180238	0.844578
baz	two	0.233350	-1.366278

stacked.unstack(0)

	first	bar	baz
second
one	A	0.055334	0.180238
one	B	0.953745	0.844578
two	A	1.719361	0.233350
two	B	0.419879	-1.366278

stacked.unstack(1)

	second	one	two
first
bar	A	0.055334	1.719361
bar	B	0.953745	0.419879
baz	A	0.180238	0.233350
baz	B	0.844578	-1.366278

数据透视表Pivot Tables

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

	A	B	C	D	E
0	one	A	foo	0.353420	-0.570327
1	one	B	foo	1.090713	-0.046794
2	two	C	foo	-0.160874	0.595251
3	three	A	bar	0.884684	-0.027981
4	one	B	bar	0.379335	-0.387736
5	one	C	bar	0.045674	1.210791
6	two	A	foo	0.264520	-1.120149
7	three	B	foo	1.149012	0.213768
8	one	C	foo	-0.965242	-0.232711
9	one	A	bar	-0.464023	0.799239
10	two	B	bar	0.186186	-0.889300
11	three	C	bar	0.177992	1.352036

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

	C	bar	foo
A	B
one	A	-0.464023	0.353420
	B	0.379335	1.090713
	C	0.045674	-0.965242
three	A	0.884684	NaN
	B	NaN	1.149012
	C	0.177992	NaN
two	A	NaN	0.264520
	B	0.186186	NaN
	C	NaN	-0.160874

时间序列

pandas具有简单、强大、高效的用于频率变换的重采样操作（例如将季节性数据变为以5分钟为间隔的数据）。

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

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

rng

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')

ts

2012-01-01 00:00:00    244
2012-01-01 00:00:01     57
2012-01-01 00:00:02      2
2012-01-01 00:00:03    175
2012-01-01 00:00:04    486
2012-01-01 00:00:05     71
2012-01-01 00:00:06     71
2012-01-01 00:00:07    430
2012-01-01 00:00:08    276
2012-01-01 00:00:09    283
2012-01-01 00:00:10    358
2012-01-01 00:00:11    465
2012-01-01 00:00:12    358
2012-01-01 00:00:13     20
2012-01-01 00:00:14    296
2012-01-01 00:00:15    397
2012-01-01 00:00:16    485
2012-01-01 00:00:17    358
2012-01-01 00:00:18    429
2012-01-01 00:00:19    148
2012-01-01 00:00:20    166
2012-01-01 00:00:21    333
2012-01-01 00:00:22     43
2012-01-01 00:00:23    352
2012-01-01 00:00:24    180
2012-01-01 00:00:25     79
2012-01-01 00:00:26     97
2012-01-01 00:00:27    344
2012-01-01 00:00:28    271
2012-01-01 00:00:29    434
                      ... 
2012-01-01 00:01:10    294
2012-01-01 00:01:11     22
2012-01-01 00:01:12    352
2012-01-01 00:01:13    383
2012-01-01 00:01:14    175
2012-01-01 00:01:15     62
2012-01-01 00:01:16     62
2012-01-01 00:01:17     32
2012-01-01 00:01:18     16
2012-01-01 00:01:19    110
2012-01-01 00:01:20    110
2012-01-01 00:01:21    302
2012-01-01 00:01:22    268
2012-01-01 00:01:23    342
2012-01-01 00:01:24     39
2012-01-01 00:01:25    346
2012-01-01 00:01:26    461
2012-01-01 00:01:27    305
2012-01-01 00:01:28    435
2012-01-01 00:01:29    370
2012-01-01 00:01:30    319
2012-01-01 00:01:31    376
2012-01-01 00:01:32     97
2012-01-01 00:01:33    437
2012-01-01 00:01:34    287
2012-01-01 00:01:35    335
2012-01-01 00:01:36    334
2012-01-01 00:01:37    106
2012-01-01 00:01:38    295
2012-01-01 00:01:39    122
Freq: S, dtype: int64

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

2012-01-01    24806
Freq: 5T, dtype: int64

rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')

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

ts

2012-03-06    0.954522
2012-03-07    0.944713
2012-03-08    1.299799
2012-03-09    1.766374
2012-03-10   -0.703189
Freq: D, dtype: float64

ts_utc = ts.tz_localize('UTC')

ts_utc

2012-03-06 00:00:00+00:00    0.954522
2012-03-07 00:00:00+00:00    0.944713
2012-03-08 00:00:00+00:00    1.299799
2012-03-09 00:00:00+00:00    1.766374
2012-03-10 00:00:00+00:00   -0.703189
Freq: D, dtype: float64

# 转为另一个时区
ts_utc.tz_convert('US/Eastern')

2012-03-05 19:00:00-05:00    0.954522
2012-03-06 19:00:00-05:00    0.944713
2012-03-07 19:00:00-05:00    1.299799
2012-03-08 19:00:00-05:00    1.766374
2012-03-09 19:00:00-05:00   -0.703189
Freq: D, dtype: float64

类别（Categoricals）

从0.15版本起，pandas可以在DataFrame中包含类别数据。

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

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

df["grade"]

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

# Series.cat.categories 可以将类别重命名为更有意义的名字
df["grade"].cat.categories = ["very good", "good", "very bad"]

df

	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

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

df

	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

df.sort_values(by="grade")

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

按类别对数据进行排序

# 统计每个类别出现的次数
df.groupby("grade").size()

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

画图

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

ts = ts.cumsum()

%matplotlib inline
ts.plot()

# DataFrame
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') #自动调整在最佳位置放置legend图标

读取和保存数据

CSV:
df.to_csv(‘foo.csv’)
pd.read_csv(‘foo.csv’)

HDF5:
df.to_hdf(‘foo.h5’,’df’)
pd.read_hdf(‘foo.h5’,’df’)

Excel:
df.to_excel(‘foo.xlsx’, sheet_name=’Sheet1’)
pd.read_excel(‘foo.xlsx’, ‘Sheet1’, index_col=None, na_values=[‘NA’])

附录

本文是对pandas 0.18.1 documentation进行学习的一次学习记录。
原文见10 Minutes to pandas。虽然号称10分钟入门，但也只限于水过地皮湿的理解程度或作为手头的应急查阅文件。我在jupyter-notebook中一步一步按照代码敲下来，边学边理解大概需要四个小时。

你可能感兴趣的:(python)

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
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打造数据可视化大屏，并通过实际代码案例
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
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
python中的深拷贝与浅拷贝 anshejd70787 python
深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
用Python实现简单的猜数字游戏程序媛了了 python 游戏 java
猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
用Python实现读取统计单词个数程序媛了了 python 游戏 java
完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
ztree设置禁用节点 3213213333332132 JavaScript ztree json setDisabledNode Ajax
ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 $(function(){ showTree(); setDisabledNode(); });
JVM patch by Taobao bookjovi java HotSpot
在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。 7050685：jsdbproc64.sh has a typo in the package name 7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 7060619：C1 should respect inline and
将session存储到数据库中 dcj3sjt126com sql PHP session
CREATE TABLE sessions ( id CHAR(32) NOT NULL, data TEXT, last_accessed TIMESTAMP NOT NULL, PRIMARY KEY (id) ); <?php /** * Created by PhpStorm. * User: michaeldu * Date
Vector 171815164 vector
public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) { for (int i = 0; i < cart.size(); i++) { if (cart.get(i).getId().equals(id)) { cart.remove(i);
各连接池配置参数比较 g21121 连接池
排版真心费劲，大家凑合看下吧，见谅~ Druid DBCP C3P0 Proxool 数据库用户名称 Username Username User 数据库密码 Password Password Password 驱动名
[简单]mybatis insert语句添加动态字段 53873039oycg mybatis
mysql数据库,id自增,配置如下： <insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id" parameterType=&
struts2拦截器配置云端月影 struts2拦截器
struts2拦截器interceptor的三种配置方法方法1. 普通配置法 <struts> <package name="struts2" extends="struts-default"> &
IE中页面不居中，火狐谷歌等正常 aijuans IE中页面不居中
问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
String,int,Integer,char 几个类型常见转换 antonyup_2006 html sql .net
如何将字串 String 转换成整数 int? int i = Integer.valueOf(my_str).intValue(); int i=Integer.parseInt(str); 如何将字串 String 转换成Integer ? Integer integer=Integer.valueOf(str); 如何将整数 int 转换成字串 String ? 1.
PL/SQL的游标类型百合不是茶显示游标(静态游标)隐式游标游标的更新和删除 %rowtype ref游标(动态游标)
游标是oracle中的一个结果集,用于存放查询的结果; PL/SQL中游标的声明; 1,声明游标 2,打开游标(默认是关闭的); 3,提取数据 4,关闭游标注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标隐式游标:主要是对DML数据的操作隐
JUnit4中@AfterClass @BeforeClass @after @before的区别对比 bijian1013 JUnit4 单元测试
一.基础知识 JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
精通Oracle10编程SQL(12)开发包 bijian1013 oracle 数据库 plsql
/* *开发包 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数） */ --包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成 --建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等 --在包规
【EhCache二】ehcache.xml配置详解 bit1129 ehcache.xml
在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ ehcache.xml ： http://ehcache.org/ehcache.xml ehcache.xsd ： http://ehcache.org/ehcache.xsd ehcache配置文件的根元素是ehcahe ehcac
java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL 白糖_ java eclipse spring tomcat Web
今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> 随后启动
angular.element boyitech AngularJS AngularJS API angular.element
angular.element 描述: 包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
java-给定两个已排序序列，找出共同的元素。 bylijinnan java
import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class CommonItemInTwoSortedArray { /** * 题目：给定两个已排序序列，找出共同的元素。 * 1.定义两个指针分别指向序列的开始。 * 如果指向的两个元素
sftp 异常，有遇到的吗？求解 Chen.H java jcraft auth jsch jschexception
com.jcraft.jsch.JSchException: Auth cancel at com.jcraft.jsch.Session.connect(Session.java:460) at com.jcraft.jsch.Session.connect(Session.java:154) at cn.vivame.util.ftp.SftpServerAccess.connec
[生物智能与人工智能]神经元中的电化学结构代表什么? comsci 人工智能
我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色.... 我们可以尝试一下...在某些神经
通过LAC和CID获取经纬度信息 dai_lm lac cid
方法1：用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度方法2：发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
JAVA的困难分析 datamachine java
前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。 -----------------------------------------------------------------------------------------
小学5年级英语单词背诵第二课 dcj3sjt126com english word
money 钱 paper 纸 speak 讲，说 tell 告诉 remember 记得，想起 knock 敲，击，打 question 问题 number 数字，号码 learn 学会，学习 street 街道 carry 搬运，携带 send 发送，邮寄，发射 must 必须 light 灯，光线，轻的 front
linux下面没有tree命令 dcj3sjt126com linux
centos p安装 yum -y install tree mac os安装 brew install tree 首先来看tree的用法 tree 中文解释：tree 功能说明：以树状图列出目录的内容。语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
Map迭代方式，Map迭代，Map循环蕃薯耀 Map循环 Map迭代 Map迭代方式
Map迭代方式，Map迭代，Map循环 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年
Spring Cache注解+Redis hanqunfeng spring
Spring3.1 Cache注解依赖jar包：  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId>
Guava中针对集合的 filter和过滤功能 jackyrong filter
在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： @Test public void whenFilterWithIterables_thenFiltered() { List<String> names = Lists.newArrayList("John"
学习编程那点事 lampcy 编程 android PHP html5
一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
架构师之流处理---------bytebuffer的mark,limit和flip nannan408 ByteBuffer
1.前言。如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思。 2.例子. 例子代码: String str = "helloWorld"; ByteBuffer buff = ByteBuffer.wrap(str.getBytes()); Sy
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1 Everyday都不同 $转义 el表达式
最近在做Highcharts的过程中，在写js时，出现了以下异常：严重: Servlet.service() for servlet jsp threw exception org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1,
用Java实现发送邮件到163 tntxia java实现
/* 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。此篇仅介绍用
探索实体类存在的真正意义 java小叶檀 POJO
一. 实体类简述实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 POJO（Plain Old Java Objects）简单的Java对象它的一般格式就是 public class A{ private String id; public Str