pandas入门

首先，下面所有的例子均需要导入包：

# 设置为 inline 风格
%matplotlib inline
# 包导入
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

一维数组：Series：

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

输出：

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

二维数组创建：

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

输出

	A	B	C	D
2016-03-01	-0.859805	-0.069692	-0.905092	-0.553213
2016-03-02	-0.353785	0.031793	-0.785213	-0.212337
2016-03-03	1.719976	0.925145	0.241639	-0.490166
2016-03-04	-1.207854	-0.001647	-0.468976	-0.781144
2016-03-05	0.452034	1.371208	1.152729	1.470498
2016-03-06	1.378227	0.246941	-1.186630	-0.411647

df.valuesarray([[-8.59804740e-01, -6.96922374e-02, -9.05091676e-01,-5.53212518e-01],[-3.53785450e-01,  3.17933613e-02, -7.85212585e-01,-2.12337229e-01],[ 1.71997643e+00,  9.25144720e-01,  2.41639347e-01,-4.90166361e-01],[-1.20785422e+00, -1.64720630e-03, -4.68976209e-01,-7.81144372e-01],[ 4.52033577e-01,  1.37120779e+00,  1.15272905e+00,1.47049771e+00],[ 1.37822701e+00,  2.46941166e-01, -1.18662963e+00,-4.11647030e-01]])

用字典来构建DataFrame，如下：

# 使用字典来创建：key 为 DataFrame 的列；value 为对应列下的值
df1 = pd.DataFrame({'A': 1,'B': pd.Timestamp('20160301'),'C': range(4),'D': np.arange(5, 9),'E': 'text','F': ['AA', 'BB', 'CC', 'DD']})
df1

	A	B	C	D	E	F
0	1	2016-03-01	0	5	text	AA
1	1	2016-03-01	1	6	text	BB
2	1	2016-03-01	2	7	text	CC
3	1	2016-03-01	3	8	text	DD

各个列可以通过DataFrame的属性来访问，如

df.A、df.B

type(df.A)

pandas.core.series.Series

可以看出，每一列或者每一行，都是Series数据

df.types  #查看每一列的数据类型
df.shape  #查看数据区的矩阵行列数
df.head() #查看矩阵的前五行，在函数内指定数字，可以查看指定行数
df.tail() #查看矩阵的后五行
df.index  #矩阵的行索引
df.columns#矩阵的列索引
df.values #查看矩阵的值，返回的是一个ndarray类型矩阵
df.describe()#查看矩阵的统计信息，默认是axis=0，及每一列的各行数据参与运算，生成每一列的统计信息，包括（每一列有多少值，平均值，标准差，最小值，四分位，中位数，四分之三分位，最大值），其中四分位的计算方法是减1计算法，具体可以查看百度百科
df.T      #矩阵的转置，或者使用transpose，类似numpy的方法
df.sort_index()#将行索引排序，参数axis可以指定为1，对列索引排序，ascending表示降序还是升序
df.sort_values(by='A')#依据每一列的值进行排序
df.['A']  #选择某列
df.A
df[2:4]   #选择行，数字也可以换成行索引，布尔值索引，但当行索引也是数字时，默认使用数字，使用索引的切片，是包含最后一个元素所在的行的
df.loc[]  #使用索引来查找数据
df.iloc[] #使用数字来查找数据
#例子
df.loc[:,['B','C']],也可以访问某个特定的值
#
df.at[,]     #根据行列标签（索引）选择数据
df.iat[,]    #根据数字选择数据df[df.A>0]   #根据布尔索引，找出A列大于0的行
df[df>0]     #非零的数据为NaN

矩阵运算

df['tag'] = ['a'] * 2 + ['b'] * 2 + ['c'] * 2

	A	B	C	D	tag
2016-03-01	0.033228	2.307123	-0.585367	-1.671832	a
2016-03-02	-1.967299	0.727670	-0.190863	-0.163514	a
2016-03-03	0.065359	0.696804	-0.550040	0.717347	b
2016-03-04	0.234850	0.289520	-1.087173	1.534277	b
2016-03-05	-1.459620	1.040987	0.220130	-0.068131	c
2016-03-06	0.865402	2.650889	-0.015460	-0.111889	c

df[df.tag.isin(['a', 'c'])]

	A	B	C	D	tag
2016-03-01	0.033228	2.307123	-0.585367	-1.671832	a
2016-03-02	-1.967299	0.727670	-0.190863	-0.163514	a
2016-03-05	-1.459620	1.040987	0.220130	-0.068131	c
2016-03-06	0.865402	2.650889	-0.015460	-0.111889	c

### 修改元素

s = pd.Series(np.arange(6), index=pd.date_range('20160301', periods=6))
df['E'] = s   # 修改一列
df.at[pd.Timestamp('20160301'), 'A'] = 0.4  #  修改某个元素
df.B = 200  #将一列的值都修改成一个值
df.iloc[:,2:5] = 1000 #修改子表

要结束网页的jupyter notebook，在控制台两次ctrl+c

重建索引

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

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

### 处理丢失数据

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

此时的E列有两个空值

df1.dropna()  #去除了空值所在的行
df1.fillna(value=5) #将空值替换成5
pd.isnull(df1) #判断是否有空数据
pd.isnull(df1).any()#列中是否有空数据
pd.isnull(df1).any().any()#表中是否有空数据

统计

空数据是不参与统计计算的

df1.mean()  #各列的平均值
df.sum(axis='columns') #计算加和
df.cumsum() #计算累加值
s = pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)  #shift表示数据段整体往后移动两个位置，前面空出来的位置为NaN
df.sub(s, axis='index')#每个列都减处理，控制行变成空值，一般都是对空值做预处理在减
df.apply(np.cumsum) #效果同df.cumsum()，注意这里的sumsum属于np模块，不是pd模块，apply是吧一个列作为参数传给函数，applymap是把每个元素做处理
df.apply(lambda x: x.max() - x.min()) #得出每一列最大值减最小值

s = pd.Series(np.random.randint(0, 7, size=10)) ￥不包括最后一个数，但python自带函数是包括的
s.value_counts() #统计各种数字的数量
s.mode()         #最多的数是哪些

数据合并

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

df1 = pd.concat([df.iloc[:3], df.iloc[3:7], df.iloc[7:]])
(df == df1).all().all()  #判断两个矩阵是否相等# SQL 样式的联合查询
left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})
right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})
# SELECT * FROM left INNER JOIN right ON left.key = right.key;
pd.merge(left, right, on='key')s = pd.Series(np.random.randint(1, 5, size=4), index=list('ABCD'))
df.append(s, ignore_index=True)

如果s有五列，在插入后，多出来新的一列，除了最后一行以外，其他都是NaN

分组统计

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

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

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

形成了双索引的结构

数据整形

tuples = list(zip(*[['bar', 'bar', 'baz', 'baz','foo', 'foo', 'qux', 'qux'],['one', 'two', 'one', 'two','one', 'two', 'one', 'two']]))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])

stacked = df.stack()

first  second
bar    one     A    0.072026B    0.422077two     A   -1.099181B   -0.354796
baz    one     A    1.285500B   -1.185525two     A    0.645316B   -0.660115
foo    one     A    0.696443B   -1.664527two     A    0.718399B   -0.154125
qux    one     A   -0.740052B    0.713089two     A   -0.672748B   -1.346843
dtype: float64

stacked.unstack()  #装换成以前的样子了
stacked.unstack().unstack()

#可以指明选择哪一列作为列索引
stacked.unstack(1)

<div>
<table border="1" class="dataframe"><thead><tr style="text-align: right;"><th></th><th>second</th><th>one</th><th>two</th></tr><tr><th>first</th><th></th><th></th><th></th></tr></thead><tbody><tr><th rowspan="2" valign="top">bar</th><th>A</th><td>0.072026</td><td>-1.099181</td></tr><tr><th>B</th><td>0.422077</td><td>-0.354796</td></tr><tr><th rowspan="2" valign="top">baz</th><th>A</th><td>1.285500</td><td>0.645316</td></tr><tr><th>B</th><td>-1.185525</td><td>-0.660115</td></tr><tr><th rowspan="2" valign="top">foo</th><th>A</th><td>0.696443</td><td>0.718399</td></tr><tr><th>B</th><td>-1.664527</td><td>-0.154125</td></tr><tr><th rowspan="2" valign="top">qux</th><th>A</th><td>-0.740052</td><td>-0.672748</td></tr><tr><th>B</th><td>0.713089</td><td>-1.346843</td></tr></tbody>
</table>
</div>

数据透视表

数据透视是指查看里面的一部分数据

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

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

**当这个数据透视表对应多个值时，回去取平均值**

时间序列

rng = pd.date_range('20160301', periods=600, freq='s')
rng

DatetimeIndex(['2016-03-01 00:00:00', '2016-03-01 00:00:01','2016-03-01 00:00:02', '2016-03-01 00:00:03','2016-03-01 00:00:04', '2016-03-01 00:00:05','2016-03-01 00:00:06', '2016-03-01 00:00:07','2016-03-01 00:00:08', '2016-03-01 00:00:09',...'2016-03-01 00:09:50', '2016-03-01 00:09:51','2016-03-01 00:09:52', '2016-03-01 00:09:53','2016-03-01 00:09:54', '2016-03-01 00:09:55','2016-03-01 00:09:56', '2016-03-01 00:09:57','2016-03-01 00:09:58', '2016-03-01 00:09:59'],dtype='datetime64[ns]', length=600, freq='S')

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

2016-03-01 00:00:00     34
2016-03-01 00:00:01      4
2016-03-01 00:00:02    382
2016-03-01 00:00:03    164
2016-03-01 00:00:04    178
2016-03-01 00:00:05    421
2016-03-01 00:00:06     34
2016-03-01 00:00:07     71
2016-03-01 00:00:08    316
2016-03-01 00:00:09    201
2016-03-01 00:00:10    214
2016-03-01 00:00:11    443
2016-03-01 00:00:12    185
2016-03-01 00:00:13     79
2016-03-01 00:00:14     38
2016-03-01 00:00:15    465
2016-03-01 00:00:16    309
2016-03-01 00:00:17     93
2016-03-01 00:00:18     20
2016-03-01 00:00:19    338
2016-03-01 00:00:20    149
2016-03-01 00:00:21     34
2016-03-01 00:00:22    257
2016-03-01 00:00:23    462
2016-03-01 00:00:24     41
2016-03-01 00:00:25    471
2016-03-01 00:00:26    313
2016-03-01 00:00:27    224
2016-03-01 00:00:28     78
2016-03-01 00:00:29    498...
2016-03-01 00:09:30     61
2016-03-01 00:09:31    315
2016-03-01 00:09:32    388
2016-03-01 00:09:33    391
2016-03-01 00:09:34    263
2016-03-01 00:09:35     11
2016-03-01 00:09:36     61
2016-03-01 00:09:37    400
2016-03-01 00:09:38    109
2016-03-01 00:09:39    135
2016-03-01 00:09:40    267
2016-03-01 00:09:41    248
2016-03-01 00:09:42    469
2016-03-01 00:09:43    155
2016-03-01 00:09:44    284
2016-03-01 00:09:45    168
2016-03-01 00:09:46    228
2016-03-01 00:09:47    244
2016-03-01 00:09:48    442
2016-03-01 00:09:49    450
2016-03-01 00:09:50    226
2016-03-01 00:09:51    370
2016-03-01 00:09:52    192
2016-03-01 00:09:53    325
2016-03-01 00:09:54     82
2016-03-01 00:09:55    154
2016-03-01 00:09:56    285
2016-03-01 00:09:57     22
2016-03-01 00:09:58     48
2016-03-01 00:09:59    171
Freq: S, dtype: int32

#重新采样
ts.resample('2Min', how='sum')

2016-03-01 00:00:00    28595
2016-03-01 00:02:00    29339
2016-03-01 00:04:00    28991
2016-03-01 00:06:00    30789
2016-03-01 00:08:00    30131
Freq: 2T, dtype: int32

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

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='int64', freq='Q-NOV')

prng.to_timestamp()   #转成标准格式数据 年-月-日
pd.Timestamp('20160301')-pd.Timestamp('2016') #计算时间差

类别数据

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

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

df["grade"].cat.categories

Index([u'a', u'b', u'e'], dtype='object')

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

df.sort_values(by='grade', ascending=True)

画图

ts = pd.Series(np.random.randn(1000), index=pd.date_range('20000101', periods=1000))
ts = ts.cumsum()
ts

2000-01-01     0.416424
2000-01-02     0.603304
2000-01-03    -0.237965
2000-01-04     0.317450
2000-01-05     0.665045
2000-01-06     2.468087
2000-01-07     2.758852
2000-01-08     2.271343
2000-01-09     3.129609
2000-01-10     5.171241
2000-01-11     5.049896
2000-01-12     5.185316
2000-01-13     4.169058
2000-01-14     2.862306
2000-01-15     4.018617
2000-01-16     4.456694
2000-01-17     5.824236
2000-01-18     6.094983
2000-01-19     5.880954
2000-01-20     5.875111
2000-01-21     6.008481
2000-01-22     6.835501
2000-01-23     7.480405
2000-01-24     6.849335
2000-01-25     7.608887
2000-01-26     9.029474
2000-01-27     8.859222
2000-01-28     7.162806
2000-01-29     7.398013
2000-01-30     7.391844...
2002-08-28    21.728409
2002-08-29    21.757852
2002-08-30    21.047643
2002-08-31    20.114996
2002-09-01    18.769902
2002-09-02    17.417680
2002-09-03    17.917688
2002-09-04    18.064786
2002-09-05    19.312356
2002-09-06    18.633479
2002-09-07    17.711879
2002-09-08    19.162369
2002-09-09    19.697896
2002-09-10    18.895018
2002-09-11    18.590989
2002-09-12    17.278925
2002-09-13    17.730168
2002-09-14    19.058526
2002-09-15    18.898382
2002-09-16    17.048621
2002-09-17    16.443233
2002-09-18    16.842284
2002-09-19    14.627031
2002-09-20    15.500982
2002-09-21    14.640444
2002-09-22    13.183795
2002-09-23    13.383657
2002-09-24    13.006229
2002-09-25    12.311008
2002-09-26    11.674804
Freq: D, dtype: float64

ts.plot()

数据读写

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

df.to_csv('data.csv')
%ls
%more data.csv

# pd.read_csv('data.csv')
pd.read_csv('data.csv', index_col=0)#以第一列作为索引

电影数据分析

准备工作

从网站 grouplens.org/datasets/movielens 下载 MovieLens 1M Dataset 数据。

数据说明

参阅数据介绍文件 README.txt

利用 Pandas 分析电影评分数据

• 数据读取
• 数据合并
• 统计电影平均得分
• 统计活跃电影 -> 获得评分的次数越多说明电影越活跃
• 女生最喜欢的电影排行榜
• 男生最喜欢的电影排行榜
• 男女生评分差距最大的电影 -> 某类电影女生喜欢，但男生不喜欢
• 最具争议的电影排行榜 -> 评分的方差最大

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

user_names = ['user_id', 'gender', 'age', 'occupation', 'zip']
users = pd.read_table('ml-1m/users.dat', sep='::', header=None, names=user_names, engine='python')rating_names = ['user_id', 'movie_id', 'rating', 'timestamp']
ratings = pd.read_table('ml-1m/ratings.dat', sep='::', header=None, names=rating_names, engine='python')movie_names = ['movie_id', 'title', 'genres']
movies = pd.read_table('ml-1m/movies.dat', sep='::', header=None, names=movie_names, engine='python')

pandas内部有两种实现方式，一种是C语言，一种是python，这里指定python，因为C语言功能不如python多。

print len(users)
users.head(5)

6040

数据合并

data = pd.merge(pd.merge(users, ratings), movies)

len(data)
data.head(5)

data[data.user_id == 1]  #查看你用户1对所有电影的评分情况

# 按性别查看各个电影的平均评分
mean_ratings_gender = data.pivot_table(values='rating', index='title', columns='gender', aggfunc='mean')
mean_ratings_gender.head(5)

# 男女意见想差最大的电影 -> 价值观/品味冲突
mean_ratings_gender['diff'] = mean_ratings_gender.F - mean_ratings_gender.M
mean_ratings_gender.head(5)

mean_ratings_gender.sort_values(by='diff', ascending=True).head(10)

# 活跃电影排行榜
ratings_by_movie_title = data.groupby('title').size()
ratings_by_movie_title.head(5)

title
$1,000,000 Duck (1971)            37
'Night Mother (1986)              70
'Til There Was You (1997)         52
'burbs, The (1989)               303
...And Justice for All (1979)    199
dtype: int64

# 前二十大高分电影 -> 平均评分最高的电影
mean_ratings = data.pivot_table(values='rating', index='title', aggfunc='mean')
top_20_mean_ratings = mean_ratings.sort_values(ascending=False).head(20)
top_20_mean_ratings

title
Gate of Heavenly Peace, The (1995)                                     5.000000
Lured (1947)                                                           5.000000
Ulysses (Ulisse) (1954)                                                5.000000
Smashing Time (1967)                                                   5.000000
Follow the Bitch (1998)                                                5.000000
Song of Freedom (1936)                                                 5.000000
Bittersweet Motel (2000)                                               5.000000
Baby, The (1973)                                                       5.000000
One Little Indian (1973)                                               5.000000
Schlafes Bruder (Brother of Sleep) (1995)                              5.000000
I Am Cuba (Soy Cuba/Ya Kuba) (1964)                                    4.800000
Lamerica (1994)                                                        4.750000
Apple, The (Sib) (1998)                                                4.666667
Sanjuro (1962)                                                         4.608696
Seven Samurai (The Magnificent Seven) (Shichinin no samurai) (1954)    4.560510
Shawshank Redemption, The (1994)                                       4.554558
Godfather, The (1972)                                                  4.524966
Close Shave, A (1995)                                                  4.520548
Usual Suspects, The (1995)                                             4.517106
Schindler's List (1993)                                                4.510417
Name: rating, dtype: float64

# 前十大热闹电影的平均评分 -> 不一定越热闹的电影，评分越高
mean_ratings[top_10_ratings.index]

title
American Beauty (1999)                                   4.317386
Star Wars: Episode IV - A New Hope (1977)                4.453694
Star Wars: Episode V - The Empire Strikes Back (1980)    4.292977
Star Wars: Episode VI - Return of the Jedi (1983)        4.022893
Jurassic Park (1993)                                     3.763847
Saving Private Ryan (1998)                               4.337354
Terminator 2: Judgment Day (1991)                        4.058513
Matrix, The (1999)                                       4.315830
Back to the Future (1985)                                3.990321
Silence of the Lambs, The (1991)                         4.351823
Name: rating, dtype: float64

# 前二十大高分电影的热闹程度 -> 不一定评分越高的电影越热闹，可能某个很小众的电影看得人少，但评分很高
ratings_by_movie_title[top_20_mean_ratings.index]

title
Gate of Heavenly Peace, The (1995)                                        3
Lured (1947)                                                              1
Ulysses (Ulisse) (1954)                                                   1
Smashing Time (1967)                                                      2
Follow the Bitch (1998)                                                   1
Song of Freedom (1936)                                                    1
Bittersweet Motel (2000)                                                  1
Baby, The (1973)                                                          1
One Little Indian (1973)                                                  1
Schlafes Bruder (Brother of Sleep) (1995)                                 1
I Am Cuba (Soy Cuba/Ya Kuba) (1964)                                       5
Lamerica (1994)                                                           8
Apple, The (Sib) (1998)                                                   9
Sanjuro (1962)                                                           69
Seven Samurai (The Magnificent Seven) (Shichinin no samurai) (1954)     628
Shawshank Redemption, The (1994)                                       2227
Godfather, The (1972)                                                  2223
Close Shave, A (1995)                                                   657
Usual Suspects, The (1995)                                             1783
Schindler's List (1993)                                                2304
dtype: int64

# 十大好电影 -> 活跃度超过 1000 的高分电影
top_10_movies = mean_ratings[top_ratings.index].sort_values(ascending=False).head(10)
top_10_movies

title
Shawshank Redemption, The (1994)                                               4.554558
Godfather, The (1972)                                                          4.524966
Usual Suspects, The (1995)                                                     4.517106
Schindler's List (1993)                                                        4.510417
Raiders of the Lost Ark (1981)                                                 4.477725
Rear Window (1954)                                                             4.476190
Star Wars: Episode IV - A New Hope (1977)                                      4.453694
Dr. Strangelove or: How I Learned to Stop Worrying and Love the Bomb (1963)    4.449890
Casablanca (1942)                                                              4.412822
Sixth Sense, The (1999)                                                        4.406263
Name: rating, dtype: float64

pandas核心数据结构

import pandas as pd
import numpy as np

Series

Series 是一维带标签的数组，数组里可以放任意的数据（整数，浮点数，字符串，Python Object）。其基本的创建函数是：

s = pd.Series(data, index=index)

其中 index 是一个列表，用来作为数据的标签。data 可以是不同的数据类型：

• Python 字典
• ndarray 对象
• 一个标量值，如 5

从 ndaray 创建

s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
s

a    0.747292
b   -1.120276
c   -0.132692
d   -0.267813
e   -0.590904
dtype: float64

s.index

Index([u'a', u'b', u'c', u'd', u'e'], dtype='object')

s = pd.Series(np.random.randn(5))
s

0    0.324214
1   -0.183776
2   -0.518808
3    0.866421
4   -0.601668
dtype: float64

s.index

Int64Index([0, 1, 2, 3, 4], dtype='int64')

从字典创建

# 空值的默认处理
d = {'a' : 0., 'b' : 1., 'd' : 3}
s = pd.Series(d, index=list('abcd'))
s

a     0
b     1
c   NaN
d     3
dtype: float64

从标量创建

pd.Series(3, index=list('abcde'))

a    3
b    3
c    3
d    3
e    3
dtype: int64

Series特性

Series 是类 ndarray 对象

熟悉 numpy 的同学对下面的操作应该不会陌生。我们在 numpy 简介里也介绍过下面的索引方式。

s = pd.Series(np.random.randn(5))
s

0    0.882069
1   -0.134360
2   -0.925088
3    0.191072
4    2.546704
dtype: float64

s[0]

0.88206876023157332

s[:3]

0    0.882069
1   -0.134360
2   -0.925088
dtype: float64

s[[1, 3, 4]]

1   -0.134360
3    0.191072
4    2.546704
dtype: float64

np.exp(s)

0     2.415892
1     0.874275
2     0.396497
3     1.210546
4    12.764963
dtype: float64

np.sin(s)

0    0.772055
1   -0.133957
2   -0.798673
3    0.189911
4    0.560416
dtype: float64

Series 是类字典对象

s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
s

a   -2.149840
b   -0.924115
c    0.481231
d    1.033813
e   -0.462794
dtype: float64

s['a']

-2.1498403551053218

s['e'] = 5

s

a   -2.149840
b   -0.924115
c    0.481231
d    1.033813
e    5.000000
dtype: float64

s['g'] = 100

s

a     -2.149840
b     -0.924115
c      0.481231
d      1.033813
e      5.000000
g    100.000000
dtype: float64

'e' in s

True

'f' in s

False

# s['f']

print s.get('f')

None

print s.get('f', np.nan)

nan

标签对齐操作

s1 = pd.Series(np.random.randn(3), index=['a', 'c', 'e'])
s2 = pd.Series(np.random.randn(3), index=['a', 'd', 'e'])
print '{0}\n\n{1}'.format(s1, s2)

a   -0.917905
c   -0.744616
e    0.114522
dtype: float64a    0.721087
d   -0.471575
e    0.796093
dtype: float64

s1 + s2

name 属性

s = pd.Series(np.random.randn(5), name='Some Thing')
s

0    0.623787
1    0.517239
2    1.551314
3    1.414463
4   -1.224611
Name: Some Thing, dtype: float64

s.name

'Some Thing'a   -0.196818
c         NaN
d         NaN
e    0.910615
dtype: float64

DataFrame

DataFrame 是二维带行标签和列标签的数组。可以把 DataFrame 想你成一个 Excel 表格或一个 SQL 数据库的表格，还可以相像成是一个 Series 对象字典。它是 Pandas 里最常用的数据结构。

创建 DataFrame 的基本格式是：

df = pd.DataFrame(data, index=index, columns=columns)

其中 index 是行标签，columns 是列标签，data 可以是下面的数据：

• 由一维 numpy 数组，list，Series 构成的字典
• 二维 numpy 数组
• 一个 Series
• 另外的 DataFrame 对象

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

pd.DataFrame(d)

pd.DataFrame(d, index=['d', 'b', 'a'])

pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three'])

如果是列表，必须元素个数一样，否则会报错

d = {'one' : [1, 2, 3, 4],'two' : [21, 22, 23, 24]}

pd.DataFrame(d)

pd.DataFrame(d, index=['a', 'b', 'c', 'd'])

从结构化数据中创建

data = [(1, 2.2, 'Hello'), (2, 3., "World")]

pd.DataFrame(data)

pd.DataFrame(data, index=['first', 'second'], columns=['A', 'B', 'C'])

从字典列表创建

data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]

pd.DataFrame(data)

```python pd.DataFrame(data, index=['first', 'second']) ```

pd.DataFrame(data, columns=['a', 'b'])

从元组字典创建

了解其创建的原理，实际应用中，会通过数据清洗的方式，把数据整理成方便 Pandas 导入且可读性好的格式。最后再通过 reindex/groupby 等方式转换成复杂数据结构。

d = {('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}}

# 多级标签
pd.DataFrame(d)

从 Series 创建

s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
pd.DataFrame(s)

pd.DataFrame(s, index=['a', 'c', 'd'])

如果这里指定多列，就会报错，不同于字典作为参数进行创建

pd.DataFrame(s, index=['a', 'c', 'd'], columns=['A'])

列选择/增加/删除

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three', 'four'])
df

df['one']

0    2.045300
1   -0.550780
2    1.702775
3   -2.035681
4   -1.092208
5    0.093502
Name: one, dtype: float64

df['three'] = df['one'] + df['two']
df

df['flag'] = df['one'] > 0
df

del df['three']
df

four = df.pop('four')
four

0   -0.639517
1    0.217392
2   -0.534071
3    0.178378
4   -0.611198
5   -0.258723
Name: four, dtype: float64

df

df['five'] = 5
df

df['one_trunc'] = df['one'][:2]
df

# 指定插入位置
df.insert(1, 'bar', df['one'])
df

使用 assign() 方法来插入新列

更方便地使用 methd chains 的方法来实现

df = pd.DataFrame(np.random.randint(1, 5, (6, 4)), columns=list('ABCD'))
df

df.assign(Ratio = df['A'] / df['B'])

insert是直接改变原DataFrame，assign是生成一个新的，assign的另一个特性是可以传入函数进行计算。

df.assign(AB_Ratio = lambda x: x.A / x.B, CD_Ratio = lambda x: x.C - x.D)

df.assign(AB_Ratio = lambda x: x.A / x.B).assign(ABD_Ratio = lambda x: x.AB_Ratio * x.D)

索引和选择

对应的操作，语法和返回结果

• 选择一列 -> df[col] -> Series
• 根据行标签选择一行 -> df.loc[label] -> Series
• 根据行位置选择一行 -> df.iloc[label] -> Series
• 选择多行 -> df[5:10] -> DataFrame
• 根据布尔向量选择多行 -> df[bool_vector] -> DataFrame

df = pd.DataFrame(np.random.randint(1, 10, (6, 4)), index=list('abcdef'), columns=list('ABCD'))
df

df['A']

a    2
b    8
c    4
d    7
e    8
f    4
Name: A, dtype: int32

df.loc['a']

A    2
B    2
C    6
D    6
Name: a, dtype: int32

df.iloc[0]

A    2
B    2
C    6
D    6
Name: a, dtype: int32

df[1:4]

使用iloc比这样直接访问效率要高df.iloc[1:4]

df[[False, True, True, False, True, False]]

数据对齐

DataFrame 在进行数据计算时，会自动按行和列进行数据对齐。最终的计算结果会合并两个 DataFrame。

df1 = pd.DataFrame(np.random.randn(10, 4), index=list('abcdefghij'), columns=['A', 'B', 'C', 'D'])
df1

df2 = pd.DataFrame(np.random.randn(7, 3), index=list('cdefghi'), columns=['A', 'B', 'C'])
df2

df1 + df2

df1 - df1.iloc[0]

这里两个运算对象不是同类型，用到广播原理，生成新的DataFrame，是原来DataFrame的每行减去第0行。

使用 numpy 函数

Pandas 与 numpy 在核心数据结构上是完全兼容的

df = pd.DataFrame(np.random.randn(10, 4), columns=['one', 'two', 'three', 'four'])
df

np.exp(df)

np.asarray(df) == df.values

array([[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True],[ True,  True,  True,  True]], dtype=bool)

type(np.asarray(df))

numpy.ndarray

np.asarray(df) == df

Panel

Panel 是三维带标签的数组。实际上，Pandas 的名称由来就是由 Panel 演进的，即 pan(el)-da(ta)-s。Panel 比较少用，但依然是最重要的基础数据结构之一。

• items: 坐标轴 0，索引对应的元素是一个 DataFrame
• major_axis: 坐标轴 1, DataFrame 里的行标签
• minor_axis: 坐标轴 2, DataFrame 里的列标签

data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),'Item2' : pd.DataFrame(np.random.randn(4, 2))}
pn = pd.Panel(data)
pn

<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

pn['Item1']

pn.items

Index([u'Item1', u'Item2'], dtype='object')

pn.major_axis

Int64Index([0, 1, 2, 3], dtype='int64')

pn.minor_axis

Int64Index([0, 1, 2], dtype='int64')

# 函数调用
pn.major_xs(pn.major_axis[0])

# 函数调用
pn.minor_xs(pn.major_axis[1])

pn.to_frame()

自动去除了NaN一列

基础运算

import pandas as pd
import numpy as np

重新索引

Series

s = pd.Series([1, 3, 5, 6, 8], index=list('acefh'))
s

a    1
c    3
e    5
f    6
h    8
dtype: int64

s.reindex(list('abcdefgh'))

a     1
b   NaN
c     3
d   NaN
e     5
f     6
g   NaN
h     8
dtype: float64

s.reindex(list('abcdefgh'), fill_value=0)

a    1
b    0
c    3
d    0
e    5
f    6
g    0
h    8
dtype: int64

# method='bfill'
s.reindex(list('abcdefgh'), method='ffill')

a    1
b    1
c    3
d    3
e    5
f    6
g    6
h    8
dtype: int64

DataFrame

df = pd.DataFrame(np.random.randn(4, 6), index=list('ADFH'), columns=['one', 'two', 'three', 'four', 'five', 'six'])
df

df2 = df.reindex(index=list('ABCDEFGH'))
df2

默认也可以不写index，但columns得写

reindex是拷贝一份数据出来

df.reindex(columns=['one', 'three', 'five', 'seven'])

df.reindex(columns=['one', 'three', 'five', 'seven'], fill_value=0)

# fill method 只对行有效
df.reindex(columns=['one', 'three', 'five', 'seven'], method='ffill')

df.reindex(index=list('ABCDEFGH'), method='ffill')

丢弃部分数据

df = pd.DataFrame(np.random.randn(4, 6), index=list('ABCD'), columns=['one', 'two', 'three', 'four', 'five', 'six'])
df

df.drop('A')

df2 = df.drop(['two', 'four'], axis=1)
df2

drop是是拷贝一份数据出来的

广播运算

df = pd.DataFrame(np.arange(12).reshape(4, 3), index=['one', 'two', 'three', 'four'], columns=list('ABC'))
df

df.loc['one']

A    0
B    1
C    2
Name: one, dtype: int64

df - df.loc['one']

函数应用

• apply: 将数据按行或列进行计算
• applymap: 将数据按元素为进行计算

df = pd.DataFrame(np.arange(12).reshape(4, 3), index=['one', 'two', 'three', 'four'], columns=list('ABC'))
df

# 每一列作为一个 Series 作为参数传递给 lambda 函数
df.apply(lambda x: x.max() - x.min())

A    9
B    9
C    9
dtype: int64

# 每一行作为一个 Series 作为参数传递给 lambda 函数
df.apply(lambda x: x.max() - x.min(), axis=1)

one      2
two      2
three    2
four     2
dtype: int64

# 返回多个值组成的 Series
def min_max(x):return pd.Series([x.min(), x.max()], index=['min', 'max'])
df.apply(min_max, axis=1)

# applymap: 逐元素运算
df = pd.DataFrame(np.random.randn(4, 3), index=['one', 'two', 'three', 'four'], columns=list('ABC'))
df

formater = '{0:.02f}'.format
# formater = lambda x: '%.02f' % x
df.applymap(formater)

0表示第0个参数，formater的写法也是一种函数

排序和排名

df = pd.DataFrame(np.random.randint(1, 10, (4, 3)), index=list('ABCD'), columns=['one', 'two', 'three'])
df

df.sort_values(by='one')

s = pd.Series([3, 6, 2, 6, 4])

s.rank()

0    2.0
1    4.5
2    1.0
3    4.5
4    3.0
dtype: float64

s.rank(method='first', ascending=False)

method='first’表示并列时，先出现排前面
默认是average，还有一种是last

0    4
1    1
2    5
3    2
4    3
dtype: float64

DataFrame默认是按照每列进行排名，与sort_values不同

数据唯一性及成员资格

适用于 Series

s = pd.Series(list('abbcdabacad'))
s

0     a
1     b
2     b
3     c
4     d
5     a
6     b
7     a
8     c
9     a
10    d
dtype: object

s.unique()

array(['a', 'b', 'c', 'd'], dtype=object)

s.value_counts()

a    4
b    3
d    2
c    2
dtype: int64

s.isin(['a', 'b', 'c'])

0      True
1      True
2      True
3      True
4     False
5      True
6      True
7      True
8      True
9      True
10    False
dtype: bool

python数据科学包第二天相关推荐

1. python 数据科学 包_什么时候应该使用哪个Python数据科学软件包？

   python 数据科学 包 Python is the most popular language for data science. Unfortunately, it can be tricky ...

2. 看看这些鲜为人知的宝藏Python数据科学包吧!

   动态数据科学的这三剑客几乎无人不知无人不晓:Numpy,Pandas和Matplotlib.你可能已经熟悉这些包以及它们的运作方式. 还有其他很炫酷的包,你肯定也想试一试,例如Plotly,Seabo ...

3. python数据科学包第三天（索引、分组计算、数据聚合、分组运算和转换、载入数据、日期范围、数据可视化）

   索引 行索引 列索引 索引的分类 重复索引的处理 s = pd.Series(np.random.rand(5), index=list('abcde')) s a 0.566924 b 0.6034 ...

4. Python数据科学包（六）-----数据可视化和例子

   文章目录 一. 数据可视化 1. 线型图 2. 柱状图 3. 直方图 4. 密度图 5. 散布图 6. 饼图 7. 高级绘图 二. 股票数据分析 1. 分析波动幅度 2. 增长曲线 3. 增长倍数 4 ...

5. python数据科学包（七）—— matplotlib实战之绘制球员能力图和股票K线图

   1.球员能力图 # -*- coding: utf-8 -*- import numpy as np import pandas as pd import matplotlib.pyplot as p ...

6. 使用python构建向量空间_使用Docker构建Python数据科学容器

   人工智能(AI)和机器学习(ML)最近真的火了,并驱动了从自动驾驶汽车到药物发现等等应用领域的快速发展.AI和ML的前途一片光明. 另一方面,Docker通过引入临时轻量级容器彻底改变了计算世界.通过 ...

7. python第二阶段（2）入门-数据科学包 pandas

   数据科学包 pandas 导入pandas 创建对象 1 系列 2 日期序列(1) 3 日期序列(2) 4 Series的操作(1) 5 Series的操作(2) 合并,新增,连接和比较 1 连接 2 ...

8. python数据科学手册_小白入门Python数据科学

   前言 本文讲解了从零开始学习Python数据科学的全过程,涵盖各种工具和方法 你将会学习到如何使用python做基本的数据分析 你还可以了解机器学习算法的原理和使用 说明 先说一段题外话.我是一名数据 ...

9. python 数据科学书籍_您必须在2020年阅读的数据科学书籍

   python 数据科学书籍 "We're entering a new world in which data may be more important than software.&qu ...

最新文章

1. python移除链表元素
2. ABAP-AVL-OO方法中的ALV的如何自己添加按钮及其响应
3. Thinkpad在Windows8上热键的解决方案
4. 【转】libpcap实现机制及接口函数
5. Spring Boot笔记-解决前后端分离在开发时的跨域问题
6. 设计模式（八）组合模式 Composite
7. Python的实例方法,类方法,静态方法之间的区别及调用关系
8. 阿里开源 iOS 协程开发框架 coobjc源码分析
9. 13-微信小程序商城 产品简介布局（微信小程序商城开发、小程序毕业设计、小程序源代码）（黄菊华-微信小程序开发教程）
10. 详述RFID服装智能管理方案
11. 在上海、苏州、深圳、长沙从“蜗居”到“安家”，8090后要付出多少？
12. 普度大学计算机科学博士,普渡大学计算机系 Yongle Zhang课题组招收全奖博士生...
13. pytorch实现bert_精细调整bert和roberta以在pytorch中实现高精度文本分类
14. Word 题注重新编号
15. ssh远程登录命令简单实例
16. 国一大佬也收藏的16个Python数据可视化案例（附源码）
17. 035 导数 微分对应表
18. 【C/C++】标准库之 numeric
19. 计算机bios设置方法,bios功能怎么设置_bios设置图解教程
20. MATLAB提取txt文本文档中特定关键字后的数字信息

热门文章

1. 星形和雪花模型_星型模型和雪花型模型比较
2. Vue跨域配置proxyTable中pathRewrite用法
3. 订单服务-----功能实现逻辑
4. DuerOS技能交互
5. C/C++语言实现一百个数组之间求任意数组的交集和并集
6. OA行业分析：大型企业如何选型OA系统?
7. CentOS 关闭virbr0
8. Clouder—构建企业级数据分析平台-墨羽@袋鼠云
9. iMovie使用技巧
10. 01-----Ubuntu16.04安装Gnome桌面环境