pandas --基础操作(一): Serise 、DataFrame 创建和数据选择 基础操作

python 数据分析

第一章 Python 数据分析之pandas的使用
第一节: pandas --基础操作(一)： Serise 、DataFrame 创建和数据选择 基础操作
第二节: pandas – 基础操作(二)： DataFrame 的增删改查、排序操作等基础操作
第三节: pandas – 基础操作(三)：pandas 层次化索引创建、数据选择
第二章 Python 数据分析之 时间戳操作
第二章 python 数据分析之numpy的使用
第三章 python 数据可视化之matplotlib的使用

---

@[TOC](文章目录)

---

前言

在数据分析中pandas 有着举足轻重的地位，提供了高性能、易使用的数据结构与数据分析工具。

---

一、pandas是什么？

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、使用步骤

1.引入库

导入pandas和numpy两个包，导入方式如下：

import numpy as np
import pandas as pd

2.对象Series、DataFrame

pandas有2个数据对象分别为Series和DataFrame，Serise为单列数据，DataFrame是为多列Serise的集合。

2.1 生成Serise

Serise是带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。轴标签统称为索引。调用 pd.Series 函数即可创建 Series。

格式: pd.Series(data,index=index)

上述代码中，data 支持以下数据类型：
- Python 字典
- 多维数组
- 标量值（如，5）
index 是轴标签列表，不同标签可以分为如下几种情况：

• 没有指定index参数

data用值列表生成 Series 时，Pandas 默认自动生成整数索引，代码如下：

In [3]: s = pd.Series([1, 3, 5, np.nan, 6, 8])
In [4]: s
Out[4]: 
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

• 多维数组

data为多维数组，data的长度和index的长度相同

s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
# np.random.randn(5)
# Out[34]: array([-0.87399137, -0.60509713, -1.07188732,  0.93279748,  0.23194527])
s
Out[35]: 
a   -0.784034
b    0.302415
c   -0.907291
d    0.207490
e   -0.652792
dtype: float64

• 字典

se = pd.Series({'a':1,'b':2,'c':4})
se
Out[42]: 
a    1
b    2
c    4
dtype: int64

注意：
data 为字典，且未设置 index 参数时，如果 Python 版本 >= 3.6 且 Pandas 版本 >= 0.23，Series 按字典的插入顺序排序索引。之前的版本按照，series按照字母顺序排序

• 标量值

se = pd.Series(5.0 ,index=[1,2,3,4,5])
se
Out[44]: 
1    5.0
2    5.0
3    5.0
4    5.0
5    5.0
dtype: float64

2.2 生成DataFrame

DataFrame 是由多种类型的列构成的二维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。DataFrame 是最常用的 Pandas 对象，与 Series 一样，DataFrame 支持多种类型的输入数据：

1. 一维 ndarray、列表、字典、Series 字典
2. 二维 numpy.ndarray
3. 结构多维数组或记录多维数组
4. Series
5. DataFrame

• 用 Series 字典或字典生成 DataFrame
  生成的index是每个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'])}
df = pd.DataFrame(d)  # 无参数结果为sereis的并集
df
Out[52]: 
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0
df = pd.DataFrame(d,index=['a','b','c'])   # 指定index
df
Out[54]: 
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
df = pd.DataFrame(d,index=['a','c'],columns=['two','aa'])  # 指定index columns
df
Out[56]: 
   two   aa
a  1.0  NaN
c  3.0  NaN

• 用列表字典生成 DataFrame，index 必须和字典长度比配，否则报错。

data = [{'a':1, 'b':2,'c':4},{'a':4,'b':55,'d':6}]
df = pd.DataFrame(data)   # 并集
df
Out[59]: 
   a   b    c    d
0  1   2  4.0  NaN
1  4  55  NaN  6.0
df = pd.DataFrame(data,index=['one','two'])
df
Out[61]: 
     a   b    c    d
one  1   2  4.0  NaN
two  4  55  NaN  6.0
df = pd.DataFrame(data,index=['one','two'],columns=['a','b'])
df
Out[63]: 
     a   b
one  1   2
two  4  55

• 用多维数组字典、列表字典生成 DataFrame

d = {'one': [1., 2., 3., 4.],
     'two': [4., 3., 2., 1.]}
     
In [45]: pd.DataFrame(d)
Out[45]: 
   one  two
0  1.0  4.0
1  2.0  3.0
2  3.0  2.0
3  4.0  1.0

In [46]: pd.DataFrame(d, index=['a', 'b', 'c', 'd'])
Out[46]: 
   one  two
a  1.0  4.0
b  2.0  3.0
c  3.0  2.0
d  4.0  1.0

• 用结构多维数组或记录多维数组生成 DataFrame

data = np.zeros((2, ), dtype=[('A', 'i4'), ('B', 'f4'), ('C', 'a10')])
data
Out[46]: 
array([(0, 0., b''), (0, 0., b'')],
      dtype=[('A', '), ('B', '), ('C', 'S10')])
data[:] = [(1, 2., 'Hello'), (2, 3., "World")]
data
Out[48]: 
array([(1, 2., b'Hello'), (2, 3., b'World')],
      dtype=[('A', '), ('B', '), ('C', 'S10')])
pd.DataFrame(data)
Out[49]: 
   A    B         C
0  1  2.0  b'Hello'
1  2  3.0  b'World'

• 用元组字典生成 DataFrame
  可以自动创建多层索引 DataFrame

pd.DataFrame({('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}})
Out[71]: 
       a              b      
       b    a    c    a     b
A B  1.0  4.0  5.0  8.0  10.0
  C  2.0  3.0  6.0  7.0   NaN
  D  NaN  NaN  NaN  NaN   9.0

3. 查看数据

 1. df.head(3)  # 查看头部默认为5， 括号里可以添加数字表示行数 
 2. df.tail(3) # 查看尾部，同上 
 3. df.index     # 查看索引 
 4.  df.columns  # 查看列明
 5.  df.describe()  #可以快速查看数据的统计摘要
 # 代码
	 Out[79]: 
	              a          b
	count  7.000000   7.000000
	mean   4.000000  10.285714
	std    2.160247   6.210590
	min    1.000000   1.000000
	25%    2.500000   6.500000
	50%    4.000000  13.000000
	75%    5.500000  14.500000
	max    7.000000  16.000000
 7. df.T  # 转置数据
 8. df.sort_index(axis=1, ascending=False) # 轴排序，根据index排序
 9. df.sort_values(by='a') # 值排序  根据“a”列的值排序
 # 代码
	 df.sort_values(by='b')
	Out[82]: 
	   a   b
	1  2   1
	2  3   2
	0  1  11
	3  4  13
	4  6  14
	5  5  15
	6  7  16
9. df.to_numpy()  # 输出底层数据的Numpy对象，输出不包含行索引和列标签，支持多种类型的转换， Pandas 和 NumPy 的本质区别：NumPy 数组只有一种数据类型，DataFrame 每列的数据类型各不相同
# 代码 
	df = pd.DataFrame({'a':[1,2,3,4],'b':[12,13,14,15]})  #  一个数据类型
	df
	Out[84]: 
	   a   b
	0  1  12
	1  2  13
	2  3  14
	3  4  15
	df.to_numpy()
	Out[85]: 
	array([[ 1, 12],
	       [ 2, 13],
	       [ 3, 14],
	       [ 4, 15]], dtype=int64)
	dff = pd.DataFrame({'A':[1,2,'aaa','bbb'],'B':['aw','de','f',2]})  # 多种数据类型，object类型
	dff
	Out[87]: 
	     A   B
	0    1  aw
	1    2  de
	2  aaa   f
	3  bbb   2
	dff.to_numpy()
	Out[88]: 
	array([[1, 'aw'],
	       [2, 'de'],
	       ['aaa', 'f'],
	       ['bbb', 2]], dtype=object)

4. 选择数据

pandas 推荐优化过的数据访问方式 ： .at ， .iat，.loc，.iloc

# 以下操作的数据
dates = pd.date_range('20130101', periods=6)  # 时间戳
df = pd.DataFrame(np.random.randn(6,4),index=datas,columns=list('abcd'))
df
	Out[99]: 
	                   a         b         c         d
	2013-01-01 -1.161403 -1.339640  0.566161 -1.680998
	2013-01-02 -2.164866 -1.020372 -1.196390 -0.417629
	2013-01-03 -0.177736 -0.197125  0.047798 -0.398154
	2013-01-04 -1.221294  0.577236  0.208095  1.333940
	2013-01-05 -0.018441  0.983021  0.832646  1.516306
	2013-01-06 -0.737595 -0.381288  0.677688 -0.890492

4.1 获取数据

1. 选取单列： df.a df[‘a’]

2. 选取多列: df[[‘a’,‘b’]]

3. 切片：[]

    df[0:3]          
    df['20130102':'20130104']
   

df[0:3] # 按行号提取数据
	Out[100]: 
	                   a         b         c         d
	2013-01-01 -1.161403 -1.339640  0.566161 -1.680998
	2013-01-02 -2.164866 -1.020372 -1.196390 -0.417629
	2013-01-03 -0.177736 -0.197125  0.047798 -0.398154
df['20130102':'20130104']
	Out[104]: 
	                   a         b         c         d
	2013-01-02 -2.164866 -1.020372 -1.196390 -0.417629
	2013-01-03 -0.177736 -0.197125  0.047798 -0.398154
	2013-01-04 -1.221294  0.577236  0.208095  1.333940

4.2 按标签选择 loc

1. df.loc[dates[0]] # 用标签提取一行
2. df.loc[dates[0]:dates[3]] # 用标签提取多行
3. df.loc[dates[0],[‘a’,‘b’]] # 一行里的多个列，返回对象降维
4. df.loc[:, [‘a’,‘b’]] # 用标签提取ab 两列
5. df.loc[dates[0],‘a’] # 提取标签值
6. df.at[dates[0],‘a’] # 同5 提取标签值

4.3 根据位置选取 iloc

1. df.iloc[3] #按整数位提取
2. df.iloc[2:3,0:2] # 按整数切片
3. df.iloc[[1,2,4],[0,2]] # 整数列按位置切片
4. df.iloc[1:3],:] # 显示整行
5. df.iloc[:,[1:3]] # 显示整列
6. df.iloc[1,1] # 提取值 ，1行1列的位置数‘

4.3 布尔索引

1. df[df.a>0] # 'a’列数值大于0的数据
2. df[df>0] # 整个df数值大于0的数据
3. df2[df2[‘E’].isin([‘two’, ‘four’])] ：isin() 筛选
4. df2[(df['A]>1)&(df[‘B’]<0.5)] ： 布尔索引和逻辑表达式一起使用，多个条件通() 实现。

 df2
	Out[43]: 
	                   A         B         C         D      E
	2013-01-01  0.469112 -0.282863 -1.509059 -1.135632    one
	2013-01-02  1.212112 -0.173215  0.119209 -1.044236    one
	2013-01-03 -0.861849 -2.104569 -0.494929  1.071804    two
	2013-01-04  0.721555 -0.706771 -1.039575  0.271860  three
	2013-01-05 -0.424972  0.567020  0.276232 -1.087401   four
	2013-01-06 -0.673690  0.113648 -1.478427  0.524988  three

In [44]: df2[df2['E'].isin(['two', 'four'])]
Out[44]: 
	                   A         B         C         D     E
	2013-01-03 -0.861849 -2.104569 -0.494929  1.071804   two
	2013-01-05 -0.424972  0.567020  0.276232 -1.087401  four

4.4 赋值

1. 根据新增列的index，直接对齐新增列的数据

se = pd.Series([1,2,3,4,5,6],index =pd.date_range('20130102',periods=6))
se
	Out[116]: 
	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'] = se
df
	Out[118]: 
	                   a         b         c         d    F
	2013-01-01 -1.161403 -1.339640  0.566161 -1.680998  NaN
	2013-01-02 -2.164866 -1.020372 -1.196390 -0.417629  1.0
	2013-01-03 -0.177736 -0.197125  0.047798 -0.398154  2.0
	2013-01-04 -1.221294  0.577236  0.208095  1.333940  3.0
	2013-01-05 -0.018441  0.983021  0.832646  1.516306  4.0
	2013-01-06 -0.737595 -0.381288  0.677688 -0.890492  5.0

2. df.at[dates[0],‘a’] = 5 # 按照标签赋值

df.at[dates[0],'a'] = 55
df
Out[121]: 
	                    a         b         c         d    F
	2013-01-01  55.000000 -1.339640  0.566161 -1.680998  NaN
	2013-01-02  -2.164866 -1.020372 -1.196390 -0.417629  1.0
	2013-01-03  -0.177736 -0.197125  0.047798 -0.398154  2.0
	2013-01-04  -1.221294  0.577236  0.208095  1.333940  3.0
	2013-01-05  -0.018441  0.983021  0.832646  1.516306  4.0
	2013-01-06  -0.737595 -0.381288  0.677688 -0.890492  5.0

3. df.iat[2,2] = 99 # 按照位置赋值

df.iat[2,2] = 99
df
Out[124]: 
	                    a         b          c         d    F
	2013-01-01  55.000000 -1.339640   0.566161 -1.680998  NaN
	2013-01-02  -2.164866 -1.020372  -1.196390 -0.417629  1.0
	2013-01-03  -0.177736 -0.197125  99.000000 -0.398154  2.0
	2013-01-04  -1.221294  0.577236   0.208095  1.333940  3.0
	2013-01-05  -0.018441  0.983021   0.832646  1.516306  4.0
	2013-01-06  -0.737595 -0.381288   0.677688 -0.890492  5.0

4. df[df>0] = -df # 选择特定值赋值

5 缺失值

1. 删除表中全部为NaN的行:data.dropna(axis = 0, how = ‘all’)
2. 删除表中任何含有NaN的行:data.dropna(axis = 0, how = ‘any’)
3. 删除表中全部为NaN的列:data.dropna(axis = 1, how = ‘all’)
4. 删除表中任何含有NaN的列:data.dropna(axis = 1 ,how = ‘any’)
5. 空值填充为values: df.fillna(values)
6. 提取中为空的bool掩码： df[pd.isna(df)]
   

---

总结

本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。