Pandas 基础

Pandas 基础


Pandas处理以下三个数据结构 -
系列(Series)系列是具有均匀数据的一维数组结构。
pandas.Series( data, index, dtype, copy)。

data:数据采取各种形式，如：ndarray，list，constants
index:索引值必须是唯一的和散列的，与数据的长度相同。 默认np.arange(n)如果没有索引被传递。因此默认情况下，它分配了从0到len(data)-1的索引
dtype:dtype用于数据类型。如果没有，将推断数据类型
copy:复制数据，默认为false。

pd.Series(data,index=[100,101,102,103]) #自定义的索引值

data = {'a' : 0., 'b' : 1., 'c' : 2.} #字典创建一个系列
s = pd.Series(data)

pd.Series(5, index=[0, 1, 2, 3]) #标量创建一个系列




数据帧(DataFrame)是一个具有异构数据（不同数据类型）的二维数组
pandas.DataFrame( data, index, columns, dtype, copy)

data:数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
index:对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
columns:对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
dtype:每列的数据类型。
copy:如果默认值为False，则此命令(或任何它)用于复制数据。


面板(Panel)面板是具有异构数据的三维数据结构。在图形表示中很难表示面板。但是一个面板可以说明为DataFrame的容器。




//===========================系列(Series)
pandas.Series( data, index, dtype, copy)。
data 数据采取各种形式，如：ndarray，list，constants
index 索引值必须是唯一的和散列的，与数据的长度相同。 默认np.arange(n)如果没有索引被传递。
dtype dtype用于数据类型。如果没有，将推断数据类型
copy 复制数据，默认为false。

//===================访问
#------通过索引位置获取   
s[0]  #返回值
s[:3] #返回Series
s[-3:] #返回Series

#------通过索引标签获取
s['a'] #返回值
s[['a','c','d']] #返回Series


//===========================数据帧(DataFrame)
pandas.DataFrame( data, index, columns, dtype, copy)
data 数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
index 对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
columns 对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
dtype 每列的数据类型。
copy 如果默认值为False，则此命令(或任何它)用于复制数据。

//===================访问
#------列选择
df ['one'] #返回Series
#------列添加
df['three']=pd.Series([10,20,30],index=['a','b','c'])
#------列删除
del df['one']
df.pop('two')

#------行选择，添加和删除
df.loc['b'] #标签选择，返回Series
df.iloc[2] #整数位置选择，返回Series

#------行切片
df[2:4] #返回DataFrame
#------添加行
df.append(df2) #将新行添加到DataFrame，返回DataFrame
#------删除行（索引标签，如果标签重复，则会删除多行）
df.drop(0) #


//===========================系列基本功能
axes 返回行轴标签列表。
dtype 返回对象的数据类型(dtype)。
empty 如果系列为空，则返回True。
ndim 返回底层数据的维数，默认定义：1。
size 返回基础数据中的元素数。
values 将系列作为ndarray返回。
head() 返回前n行。（返回Series）
tail() 返回最后n行。（返回Series）


//===========================DataFrame基本功能
T 转置行和列。
axes 返回一个列，行轴标签和列轴标签作为唯一的成员。
dtypes 返回此对象中的数据类型(dtypes)。
empty 如果NDFrame完全为空[无项目]，则返回为True; 如果任何轴的长度为0。
ndim 轴/数组维度大小。
shape 返回表示DataFrame的维度的元组。
size NDFrame中的元素数。
values NDFrame的Numpy表示。
head() 返回开头前n行。
tail() 返回最后n行。


//===========================描述性统计
count() 非空观测数量
sum() 所有值之和
mean() 所有值的平均值
median()所有值的中位数
mode() 值的模值(频数最高的那个)
std() 值的标准偏差
min() 所有值中的最小值
max() 所有值中的最大值
abs() 绝对值
prod() 数组元素的乘积
cumsum()累计总和
cumprod()累计乘积

数据帧(DataFrame) - “index”(axis=0，默认)，columns(axis=1)
//行统计(数字才计算)
df.sum(axis=1)
df.sum(0)

//列统计
df.sum(axis=0)
df.sum(0)
df.sum()

#------汇总数据(描述)
df.describe() #计算有关DataFrame列的统计信息的摘要(列)

df.describe(include=['object'])
object - 汇总字符串列
number - 汇总数字列
all - 将所有列汇总在一起(不应将其作为列表值传递)



//===========================函数应用
在整个DataFrame，行或列或元素上进行操作。
表函数应用：pipe()
行或列函数应用：apply()
元素函数应用：applymap()


#------表格函数应用
def adder(ele1,ele2):
   return ele1+ele2
df.pipe(adder,2)

就是对DataFrame中的所有无素运行adder(DataFrame,参数)，上面相当于df=df+2


#------行或列函数应用
默认情况下，操作按列执行，将每列列为数组。
??????



#------



//===========================重建索引
reindex,之前没有的索引插入缺失值(NA)标记,有的就选择取对应的,不对应的不要

reindex_like,其轴被标记为与另一个对象相同,行列索引都与目标一致

可选参数方法
pad/ffill - 向前填充值（用前一个填充）
bfill/backfill - 向后填充值（用后一个填充）
nearest - 从最近的索引值填充

df2.reindex_like(df1,method='ffill')

#------重建索引时的填充限制
df2.reindex_like(df1,method='ffill',limit=1) #限制填充1行


#------重命名
df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})



//===========================迭代
#------迭代DataFrame,迭代DataFrame提供列名(返回列名)


#------遍历数据帧(DataFrame)中的行
iteritems() - 迭代(key，value)对，(返回列名，Series)


iterrows() - 将行迭代为(索引，系列)对，(返回行名，Series)

itertuples() - 以namedtuples的形式迭代行,将为DataFrame中的每一行返回一个产生一个命名元组的迭代器。元组的第一个元素将是行的相应索引值，而剩余的值是行值。
Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)


//===========================排序
#------按标签
sort_index()方法，通过传递axis参数和排序顺序，可以对DataFrame进行排序。 默认情况下，按照升序对行标签进行排序。

sorted_df = unsorted_df.sort_index(ascending=False)#升序参数

sorted_df=unsorted_df.sort_index(axis=1)#按列排列



#------按实际值
sort_values()是按值排序的方法。它接受一个by参数，它将使用要与其排序值的DataFrame的列名称。

sorted_df = unsorted_df.sort_values(by='col1')

sorted_df = unsorted_df.sort_values(by=['col1','col2']) #指定需要列值



//===========================字符串和文本数据

1       lower()	将Series/Index中的字符串转换为小写。
2	upper()	将Series/Index中的字符串转换为大写。
3	len()	计算字符串长度。
4	strip()	帮助从两侧的系列/索引中的每个字符串中删除空格(包括换行符)。
5	split(' ')	用给定的模式拆分每个字符串。
6	cat(sep=' ')	使用给定的分隔符连接系列/索引元素。
7	get_dummies()	返回具有单热编码值的数据帧(DataFrame)。
8	contains(pattern)	如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False。
9	replace(a,b)	将值a替换为值b。
10	repeat(value)	重复每个元素指定的次数。
11	count(pattern)	返回模式中每个元素的出现总数。
12	startswith(pattern)	如果系列/索引中的元素以模式开始，则返回true。
13	endswith(pattern)	如果系列/索引中的元素以模式结束，则返回true。
14	find(pattern)	返回模式第一次出现的位置。
15	findall(pattern)	返回模式的所有出现的列表。
16	swapcase	变换字母大小写。
17	islower()	检查系列/索引中每个字符串中的所有字符是否小写，返回布尔值
18	isupper()	检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值
19	isnumeric()	检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值。

s.str.lower()
s.str.repeat(2)


//===========================索引和选择数据
.loc() 基于标签(标签进行数据获取)
.iloc() 基于整数
.ix() 基于标签和整数(两种混合便用)

#------
df.loc[行,列] #(返回Series或DataFrame)
如果行列多个用list表示
df.loc[['a','b','f','h'],['A','C']]

#------
df.iloc[行,列] #(返回Series或DataFrame)


#------使用符号(用标量) 用于访问列
df['A']
df[['A','B']]


#------属性访问(用标量)
df.A


//===========================统计函数
#------pct_change()将每个元素与其前一个元素进行比较，并计算变化百分比。
默认情况下，pct_change()对列进行操作; 如果想应用到行上，那么可使用axis = 1参数。

s.pct_change()
df.pct_change()

#------Cov()(协方差),用来计算序列对象之间的协方差。NA将被自动排除。
s1.cov(s2)
frame.cov()(两两之间的协方差)


#------corr()(相关性)相关性显示了任何两个数值(系列)之间的线性关系。
frame['a'].corr(frame['b'])
frame.corr()



//===========================窗口函数
#------rolling(滚动)
df.rolling(window=3).mean() #window=n(窗口大小),对窗口中的数据应用后面函数(统计函数)

min_periods ,最小滚动窗口，用于有些数据为NAN


#------expanding()(展开),与rolling使用一样
df.expanding(min_periods=3).mean()



//===========================聚合
#------aggregate在整个数据框上应用聚合
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)


#------在数据框的单个列上应用聚合
r = df.rolling(window=3,min_periods=1)
print (r['A'].aggregate(np.sum))


#------在DataFrame的多列上应用聚合
r = df.rolling(window=3,min_periods=1)
print (r[['A','B']].aggregate(np.sum))


#------将不同的函数应用于DataFrame的不同列
r = df.rolling(window=3,min_periods=1)
print (r.aggregate({'A' : np.sum,'B' : np.mean}))




//===========================缺失数据(NaN)
#------检查缺失值
isnull()和notnull()函数

df['one'].isnull() #(返回Series或DataFrame)

#------缺少数据的计算
在求和数据时，NA将被视为0
如果数据全部是NA，那么结果将是NA


#------清理/填充缺少数据
df.fillna(0) #用0替换NaN

#------填写NA前进和后退
pad/fill 填充方法向前
bfill/backfill 填充方法向后

df.fillna(method='pad')

#------丢失缺少的值
使用dropna函数和axis参数。 默认情况下，axis = 0，即在行上应用，这意味着如果行内的任何值是NA，那么整个行被排除。

df.dropna()
df.dropna(axis=1)

#------替换丢失(或)通用值
df.replace({1000:10,2000:60})


//===========================分组
obj.groupby(‘key’)
obj.groupby([‘key1’,’key2’])
obj.groupby(key,axis=1)


df.groupby('Team').groups #返回分组的索引信息
返回：
{
'Devils': Int64Index([2, 3], dtype='int64'),
'Kings': Int64Index([4, 6, 7], dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11], dtype='int64'),
'Royals': Int64Index([9, 10], dtype='int64'),
'kings': Int64Index([5], dtype='int64')
}

#------按多列分组
df.groupby(['Team','Year']).groups
返回：
{
('Devils', 2014): Int64Index([2], dtype='int64'),
('Devils', 2015): Int64Index([3], dtype='int64'),
('Kings', 2014): Int64Index([4], dtype='int64'),
('Kings', 2016): Int64Index([6], dtype='int64'),
('Kings', 2017): Int64Index([7], dtype='int64')
}

#------迭代遍历分组
grouped = df.groupby('Year')

for name,group in grouped:
    print (name)
    print (group)

name:分组名
group:分组里的DataFrame


#------选择一个分组get_group
grouped = df.groupby('Year')
print (grouped.get_group(2014)) #返回DataFrame


#------聚合
grouped = df.groupby('Year')
print (grouped['Points'].agg(np.mean))#返回Series


#------查看每个分组的大小(聚合)
grouped = df.groupby('Team')
print (grouped.agg(np.size))


#------一次应用多个聚合函数
grouped = df.groupby('Team')
agg = grouped['Points'].agg([np.sum, np.mean, np.std])
print (agg)

#------一转换
????????

#------一过滤
????????



//===========================合并/连接(与SQL的join一样)
#------一在一个键上合并两个数据帧
rs = pd.merge(left,right,on='id')
print(rs)


#------一合并多个键上的两个数据框
rs = pd.merge(left,right,on=['id','subject_id'])
print(rs)


#------一合并使用“how”的参数
left LEFT OUTER JOIN 使用左侧对象的键
right RIGHT OUTER JOIN 使用右侧对象的键
outer FULL OUTER JOIN 使用键的联合
inner INNER JOIN 使用键的交集

rs = pd.merge(left, right, on='subject_id', how='left')
print (rs)



//===========================级联(进行数据的联合)
#------一连接对象(索引不变)
rs = pd.concat([one,two])
print(rs)

rs = pd.concat([one,two],axis=1)
print(rs)


rs = pd.concat([one,two],keys=['x','y'],ignore_index=True)
print(rs)
#ignore_index:索引重新进行生成


#------一附加连接append，它们沿axis=0连接，即索引
rs = one.append(two)
print(rs)

rs = one.append([two,one,two]) #可以带多个对象
print(rs)



//===========================时间序列
#------一获取当前时间
pd.datetime.now()
#返回时间系列对象

#------一创建一个时间戳
time = pd.Timestamp('2018-11-01')
print(time)
#返回时间系列对象
time = pd.Timestamp(1588686880,unit='s')

#------一创建一个时间范围
time = pd.date_range("12:00", "23:59", freq="30min").time

#.time表示获取时间
#.date表示获取日期

#------一转换为时间戳
time = pd.to_datetime(pd.Series(['Jul 31, 2009','2019-10-10', None]))




//===========================日期功能
#------一创建一个日期范围( 默认情况下，范围的频率是天。)
datelist = pd.date_range('2020/11/21', periods=5)
print(datelist)

DatetimeIndex(['2020-11-21', '2020-11-22', '2020-11-23', '2020-11-24','2020-11-25'],
dtype='datetime64[ns]', freq='D')

#返回对象
#periods,表赤范围

#------一更改日期频率(freq)
datelist = pd.date_range('2020/11/21', periods=5,freq='M')
print(datelist)
#M（表示月）
#返回时间系列对象

#------一商业日期范围(不包括星期六和星期天)
bdate_range()
datelist = pd.date_range('2011/11/03', periods=5)
print(datelist)
#返回时间系列对象

#------一
start = pd.datetime(2017, 11, 1)
end = pd.datetime(2017, 11, 5)
dates = pd.date_range(start, end)
print(dates)

#------一偏移别名

B	工作日频率
BQS	商务季度开始频率
D	日历/自然日频率
A	年度(年)结束频率
W	每周频率
BA	商务年底结束
M	月结束频率
BAS	商务年度开始频率
SM	半月结束频率
BH	商务时间频率
SM	半月结束频率
BH	商务时间频率
BM	商务月结束频率
H	小时频率
MS	月起始频率
T, min	分钟的频率
SMS	SMS半开始频率
S	秒频率
BMS	商务月开始频率
L, ms	毫秒
Q	季度结束频率
U, us	微秒
BQ	商务季度结束频率
N	纳秒
BQ	商务季度结束频率
QS	季度开始频率

//===========================时间差
#------一整数(#返回时间系列对象)
timediff = pd.Timedelta(6,unit='h')

0 days 06:00:00


#------一数据偏移
timediff = pd.Timedelta(days=2)


#------一相加操作/相减操作
df['C']=df['A']+df['B']
df['D']=df['C']-df['B']


//===========================类别/分类创建
cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print (cat)

pandas.Categorical(values, categories, ordered)
#返回Categories对象
[a, b, c, a, b, c]
Categories (3, object): [a, b, c] #类别只有三个


cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print (cat)

[a, b, c, a, b, c, NaN] #d不在类别中,在类别中不存在的任何值将被视为NaN
Categories (3, object): [c, b, a]


#------一
?????????????????????????


//===========================可视化
只是使用matplotlib库的plot()方法的简单包装实现

#------一绘图
df.plot()

#------一条形图
df.plot.bar()
df.plot.bar(stacked=True)
df.plot.barh(stacked=True)

#------一直方图
df.plot.hist(bins=20)


#------一要为每列绘制不同的直方图
df.hist(bins=20)

#------一区域块图形
df.plot.area()

#------一散点图形
df.plot.scatter(x='a', y='b')

#------一饼状图
df.plot.pie(subplots=True)


//===========================IO工具
temp.csv
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

df=pd.read_csv("temp.csv")
print (df)

   S.No    Name  Age       City  Salary
0     1     Tom   28    Toronto   20000
1     2     Lee   32   HongKong    3000
2     3  Steven   43   Bay Area    8300
3     4     Ram   38  Hyderabad    3900


#------一自定义索引
df=pd.read_csv("temp.csv",index_col=['S.No'])
print (df)

       Name  Age       City  Salary
S.No                               
1        Tom   28    Toronto   20000
2        Lee   32   HongKong    3000
3     Steven   43   Bay Area    8300
4        Ram   38  Hyderabad    3900


#------一转换器
df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print (df.dtypes)

S.No        int64
Name       object
Age         int64
City       object
Salary    float64
dtype: object




#------一指定标题的名称
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print (df)

  a       b    c          d       e
0  S.No    Name  Age       City  Salary
1     1     Tom   28    Toronto   20000
2     2     Lee   32   HongKong    3000
3     3  Steven   43   Bay Area    8300
4     4     Ram   38  Hyderabad    3900

#------一原标题不存在
df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print (df)

  a       b   c          d      e
0  1     Tom  28    Toronto  20000
1  2     Lee  32   HongKong   3000
2  3  Steven  43   Bay Area   8300
3  4     Ram  38  Hyderabad   3900


#------一跳过指定的行数(跳过多少行),以列索引开始为1
df=pd.read_csv("temp.csv", skiprows=2)
print (df)

2     Lee  32   HongKong  3000
0  3  Steven  43   Bay Area  8300
1  4     Ram  38  Hyderabad  3900



//===========================稀疏数据
??????