series概念及创建
series是带有标签的一维数组
a=pd.Series(np.random.rand(5))
0 0.260108
1 0.825144
2 0.279825
3 0.574563
4 0.091617
s.index :提取标签，属于pandas.index
s.value :属于numpy.ndarray
创建：
字典创建
dic={'a':1}
pd.Series(dic)
数组创建：
ar=np.random.randn(5)
s=pd.Series(ar,index=[],dtype=np.object)
序列创建：
s=pd.Series([1,2,3])
名称属性：
s=pd.Series([1,2,3],name='number')
s2=s.rename('digit') #生成新series，原不变
dataframe概念及创建
dataframe是表格型数据结构，带有标签的二维数组
data = {'name':['Jack','Tom','Mary'],
'age':[18,19,20],
'gender':['m','m','w']}
frame=pd.DataFrame(data)
name age gender
0 Jack 18 m
1 Tom 19 m
2 Mary 20 w
frame.index.tolist
frame.colums.tolist 列名
frame.values 二维数组
name=frame['name'] #变成series
创建：
字典创建：
data1 = {'a':[1,2,3],
'b':[3,4,5],
'c':[5,6,7]}
data2 = {'one':np.random.rand(3),
'two':np.random.rand(3)}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
series创建：
data1 = {'one':pd.Series(np.random.rand(2)),
'two':pd.Series(np.random.rand(3))}
data2 = {'one':pd.Series(np.random.rand(2), index = ['a','b']),
'two':pd.Series(np.random.rand(3),index = ['a','b','c'])} #index值不等会生成NAN
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
二维数组创建：
ar = np.random.rand(3,3)
df1 = pd.DataFrame(ar)
df2 = pd.DataFrame(ar, index = ['a', 'b', 'c'], columns = ['one','two','three'])
df1=pd.DataFrame(data1,colums=['','','']，index=[]) 定义列名，可多或少于数据,索引不可以多
索引及切片
df=pd.DataFrame(np.arange(1,21).reshape(5,4),columns=['one','two','three','four'],index=['a','b','c','d','e'])
one two three four
a 1 2 3 4
b 5 6 7 8
c 9 10 11 12
d 13 14 15 16
e 17 18 19 20
df['one']
df[['one','two','three']] #索引多列
a 1
b 5
c 9
d 13
e 17
Name: one, dtype: int32
one two three
a 1 2 3
b 5 6 7
c 9 10 11
d 13 14 15
e 17 18 19
df.loc['a'] #索引一行，生成series
df.loc[['a','b','c']] #索引多行，生成dataframe
one 1
two 2
three 3
four 4
Name: a, dtype: int32
one two three four
a 1 2 3 4
b 5 6 7 8
c 9 10 11 12
df.loc['one':'three'] #包含three
df.iloc[:3] #不包含第四行
支持bool索引：
df[df<10] #只保留对应True值，其余NAN
one two three four
a 1.0 2.0 3.0 4.0
b 5.0 6.0 7.0 8.0
c 9.0 NaN NaN NaN
d NaN NaN NaN NaN
e NaN NaN NaN NaN
df[df['one']>10] #只保留one对应大于10的行
one two three four
d 13 14 15 16
e 17 18 19 20
df[df[['one','two']]>10]
one two three four
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN
d 13.0 14.0 NaN NaN
e 17.0 18.0 NaN NaN
基本技巧
查看数据：
df.head(2) #默认前五行数据
df.tail()
转置：
df.T #列名和index同样转置
添加，修改：
df['']= 修改一列，增加一个新列
df[['','']]= 修改多列，不能增加多列
df.loc['']= 修改行，不能用.iloc增加
删除：
del df[''] 删除列
df=df.iloc[1:] 删除行
df.drop([''],inplace=True) #删除行，inplace是否改变原df
df.drop([''],axis=1) #删除列
对齐：
df1+df2 :具有相同的列名和index，则相加，其余为NAN空值
排序：
df.sort_values(['列名'],inplace=True,ascending=False) :降序，默认是升序,其余行也会跟着改变
df.sort_index() ：索引排序
数值计算和统计基础
df.mean() #计算每一列的均值
df[''].mean() #某一列均值
df.mean(axis=1) #行均值
df['mean']=df.mean(axis=1) #新增一行mean
df.mean(skipna=False) #skipna参数：是否忽略NaN，默认True，如False，有NaN的列统计结果仍为NaN
df.count() '→ count统计非Na值的数量'
df.min() '→ min统计最小值\n',df['key2'].max(),'→ max统计最大值'
df.quantile(q=0.75) '→ quantile统计分位数，参数q确定位置'
df.sum() '→ sum求和'
df.mean() '→ mean求平均值'
df.median() '→ median求算数中位数，50%分位数'
df.std(),'\n',df.var() '→ std,var分别求标准差，方差'
df.skew() '→ skew样本的偏度'
df.kurt() '→ kurt样本的峰度'
df[''].cumsum() 累积和,返回series
df[''].cumprod() 累积积
df.cummax()
df.cummin()
例子：
v1 v2
a NaN 13.355255
b 92.421406 12.826767
c 58.552624 2.434633
d 20.036923 53.703573
mean 57.003651 20.580057
v1 v2
a NaN 13.355255
b 92.421406 13.355255
c 92.421406 13.355255
d 92.421406 53.703573
mean 92.421406 53.703573
唯一值
sq = df[''].unique() #只有series有唯一值，把重复的值去掉生成一个数组
sq.sort() #排序
s.value_counts(sort = False) # 也可以这样写：pd.value_counts(sc, sort = False)
# 得到一个新的Series，计算出不同值出现的频率
# sort参数：排序，默认为True
s.isin([1,2])
df.isin(['a','b',1]) # 得到一个布尔值的Series或者Dataframe
文本数据
s.str.count('b')
df[''].str.upper()
df.columns = df.columns.str.upper() #将列名大写
s.str.lower() '→ lower小写'
s.str.upper() '→ upper大写'
s.str.len() '→ len字符长'
s.str.startswith('b') '→ 判断起始是否为a'
s.str.endswith('3') '→ 判断结束是否为3'
s.str.strip() # 去除字符串中的空格
s.str.lstrip() # 去除字符串中的左空格
s.str.rstrip() # 去除字符串中的右空格
df.columns.str.replace(' ','-')
s.str.split(',')
s.str.split(',')[0] :list
s.str.split(',').str[0] :拆分后的第一个元素
s.str[0] # 取第一个字符串
s.str[:2] # 取前两个字符串
合并、连接、去重、替换
合并
pd.merge(df1, df2, on='key') on：参考键
pd.merge(df3, df4,on=['key1','key2'], how = 'inner') 交集
pd.merge(df3, df4, on=['key1','key2'], how = 'outer') 并集
pd.merge(df3, df4, on=['key1','key2'], how = 'left') left：按照df3为参考合并，数据缺失范围NaN
pd.merge(df3, df4, on=['key1','key2'], how = 'right')
pd.merge(df1, df2, left_on='lkey', right_on='rkey') df1以‘lkey’为键，df2以‘rkey’为键
pd.merge(df1, df2, left_on='key', right_index=True) left_index：为True时，第一个df以index为键，默认False
right_index：为True时，第二个df以index为键，默认False
连接
pd.concat([s1,s2]) :concat不增加维度改变axis所在维度
pd.concat([s3,s4], axis=1)
去重
s.duplicated() #得到bool
s.drop_duplicates() # drop_duplicates移除重复
替换
s = pd.Series(list('ascaazsd')
s.replace('a', np.nan)
s.replace(['a','s'] ,np.nan)
s.replace({'a':'hello world!','s':123})
# 可一次性替换一个值或多个值
# 可传入列表或字典
数据分组
df :A B C D
0 foo one 1.032719 1.105788
1 bar one -0.086132 -0.202564
2 foo two -1.279116 0.356229
3 bar three 0.506585 0.882553
4 foo two 0.232884 -1.474835
5 bar two -0.686822 -1.195990
6 foo one -0.387035 1.470906
7 foo three 0.298428 0.876817
df.groupby('A') # 按照'A'列中元素种类，直接分组得到一个groupby对象，是一个中间数据，没有进行计算
<pandas.core.groupby.groupby.DataFrameGroupBy object at 0x0000000005030828>
a = df.groupby('A').mean()
C D
A
bar -0.088790 -0.172000
foo -0.020424 0.466981 #Dataframe
b = df.groupby(['A','B']).mean()
C D
A B
bar one -0.086132 -0.202564
three 0.506585 0.882553
two -0.686822 -1.195990
foo one 0.322842 1.288347
three 0.298428 0.876817
two -0.523116 -0.559303
c = df.groupby(['A','B'])['D'].mean() # 以A,B分组，算D的平均值
A B
bar one -0.202564
three 0.882553
two -1.195990
foo one 1.288347
three 0.876817
two -0.559303
Name: D, dtype: float64 #Series类型
生成list类型：
df:X Y
0 A 1
1 B 4
2 A 3
3 B 2
list(df.groupby('X'))
[('A', X Y
0 A 1
2 A 3),
('B', X Y
1 B 4
3 B 2)]
list(df.groupby('X'))[0][1]
X Y
0 A 1
2 A 3 #Dataframe
for n,g in df.groupby('X'):
print(n)
print(g)
print('###')
A
X Y
0 A 1
2 A 3
###
B
X Y
1 B 4
3 B 2
###
df.groupby(['X']).get_group('A')
X Y
0 A 1
2 A 3
转为dict:
df.groupby('X').groups
{'A': Int64Index([0, 2], dtype='int64'),
'B': Int64Index([1, 3], dtype='int64')}
df.groupby('X').grouped.groups['A']
Int64Index([0, 2], dtype='int64')
查看分组后的长度：
grouped.size()
X
A 2
B 2
计算方法：
s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
grouped = s.groupby(level=0) # 唯一索引用.groupby(level=0)，将同一个index的分为一组
<pandas.core.groupby.groupby.SeriesGroupBy object at 0x0000000008183CF8>
grouped.first() '→ first：非NaN的第一个值'
grouped.last() '→ last：非NaN的最后一个值'
grouped.sum() '→ sum：非NaN的和'
grouped.mean() '→ mean：非NaN的平均值'
grouped.median() '→ median：非NaN的算术中位数'
grouped.count() '→ count：非NaN的值'
grouped.min() '→ min、max：非NaN的最小值、最大值'
grouped.std() '→ std，var：非NaN的标准差和方差'
grouped.prod() '→ prod：非NaN的积'
多函数：
df
a b c d
0 1 0.389265 0.813021 0.210822
1 1 0.640262 0.984044 0.042940
2 2 0.128999 0.290629 0.610907
3 2 0.976386 0.541014 0.129392
df.groupby('a').agg(['mean',np.sum])
b c d
mean sum mean sum mean sum
a
1 0.514764 1.029527 0.898533 1.797065 0.126881 0.253761
2 0.552692 1.105385 0.415822 0.831643 0.370150 0.740299
数据读取
import os
os.chdir('C:/Users/') #更改路径
data1 = pd.read_table('data1.txt', delimiter=',',header = 0, index_col=1)
# delimiter：用于拆分的字符，也可以用sep：sep = ','
# header：用做列名的序号，默认为0（第一行）
# index_col：指定某列为行索引，否则自动索引0, 1, .....
# read_table主要用于读取简单的数据，txt/csv
data2 = pd.read_csv('data2.csv',encoding = 'utf-8')
# encoding：指定字符集类型，即编码，通常指定为'utf-8'
# 大多数情况先将excel导出csv，再读取(sublime)
data3 = pd.read_excel('.xls',sheet_name=0,header=0)
# io ：文件路径。
# sheet_name：返回多表使用sheetname=[0,1],若sheet_name=None是返回全表 → ① int/string 返回的是dataframe ②而none和list返回的是dict
# header：指定列名行，默认0，即取第一行
# index_col：指定列为索引列
7788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
