[人工智能]pandas

?主要的两个结构

Series 和 DataFrame

其导入方式为

import pandas as pd

打印导入的pandas版本

pd.__version__

打印出pandas库需要的所有的版本信息

pd.show_versions()

目录

读取文件

1.读取csv文件

2.读取txt文件

3.读取excel文件

4.读取json文件

5.其中参数的主要用法

6.快速将文件格式转换为markdown形式

Series

1.Series的创建方式

2.索引

3.排序

5.替换函数

DataFrame

1.创建方式

2.DataFrame属性和操作

3.索引

4.合并操作

5.统计操作

6.apply方法

7.分组（利用groupby())

8.函数用法

9.数据排序

10.字符串操作

11.文件操作

12.行列反转

13.长表变宽表(pivot)

14.缺失值

读取文件

pandas可以读取的文件格式有很多，这里主要介绍读取csv, excel, txt，json文件。

1.读取csv文件

pd.read_csv('data.csv')

2.读取txt文件

pd.read_table('data.txt')

3.读取excel文件

pd.read_excel('data.excel')

4.读取json文件

pd.read_json('data.json')

5.其中参数的主要用法

（1）header = None

表示第一列不会作为数据的列标签

（2）index_col

表示将某一列或者多列作为行标签

（3）usecols

表示选取全部数据中的几列为一组数据，平时默认为全部

（4）nrows

表示读取行的数量，一般为全部

（5）parse_dates

表示将字符串形式的时间格式转换为时间的正常格式

（6）sep

分隔符（在使用时它使用的是正则表达式）

6.快速将文件格式转换为markdown形式

a.to_markdown()

Series

Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。（即是一个一维的数据结构，它由index（索引）和value（值）组成）

可以导入

from pandas import Series as si

1.Series的创建方式

（1）列表创建

a = pd.Series([1,2,3],index = ['a','b','c'])
?
a ? ?1
b ? ?2
c ? ?3

（2）标量值创建

a = pd.Series(25,index = ['a','b','c'])
?
a ?  25
b ?  25
c ?  25

（3）python字典

a = {'a':3500, 'b':7100, 'c':5000}
b = pd.Series(a)
?
a ? ?3500
b ? ?7100
c ? ?5000

（4）numpy创建

import numpy as np
a = pd.Series(np.arange(5),index = np.arange(10,5,-1))
?
10 ? ?0
9 ? ? 1
8 ? ? 2
7 ? ? 3
6 ? ? 4

2.索引

（1）通过索引选取Series中的单个或一组值

e = pd.Series([1,2,3,4,5], index = ['a', 'b', 'c', 'd'])
e['a']
e['d']
e[['a', 'c']]

（2）根据索引值映射到数据

e = pd.Series([1,2,3,4], index = ['a', 'b', 'c', 'd'])
'a' in e
'c' in e
?
True
False

（3）通过索引值改变索引的顺序

e = pd.Series([1,2,3,4], index = ['a', 'b', 'c', 'd'])
e.index = ['b', 'd', 'a', 'c']
e
?
b ? ?1
d ? ?2
a ? ?3
c ? ?4
dtype: int64

（4）Series与其它方式不同，它会根据运算的索引自动进行对齐数据

x = pd.Series([1,2,3,4], index = ['a','c','e','f'])
y = pd.Series([1,2,3,4], index = ['a', 'b', 'c', 'd'])
x + y
?
a ? ?2.0
b ? ?NaN
c ? ?5.0
d ? ?NaN
e ? ?NaN
f ? ?NaN
dtype: float64

NaN表示空值，要两个同时有的才会不是空值

（5）通过索引赋值进行索引的更换

a = pd.Series([1,2], index = ['a', 'b'])
a.index = ['c', 'd']
a
?
a = pd.Series([1,2], index = ['a', 'b'])
a.index = ['c', 'd']
a

（6）通过index和values以及切片获取相对应的数据

x = pd.Series([1,2,3,4], index = ['a','c','e','f'])
x.index
x.values
x.index[0:2]
x.values[0:1]
?
Index(['a', 'c', 'e', 'f'], dtype='object')
[1 2 3 4]
Index(['a', 'c'], dtype='object')
[1 2]

（7）通过标签索引 loc[] 和数值索引 iloc[]

x = pd.Series([1,2,3,4], index = ['a','c','e','f'])
x.loc['a']
x.iloc[0]
x.iloc[0:2]
?
1
1
a ?  1
c ?  2
dtype: int64

3.排序

（1）sort_index()

a = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
a.sort_index()
?
a ? ?1
b ? ?2
c ? ?3
d ? ?0
dtype: int64

（2）sort_values()（如果由缺失值，即NaN，都会被放到最低端）

a = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
a.sort_values()
?
d ? ?0
a ? ?1
b ? ?2
c ? ?3
dtype: int64

（3）计算排名

a = pd.Series([7, -5, 8, 4, 2, 0, 3])
a.rank()
?
0 ? ?6.0
1 ? ?1.0
2 ? ?7.0
3 ? ?5.0
4 ? ?3.0
5 ? ?2.0
6 ? ?4.0
dtype: float64
# 当有两个数据是一样的时候，就会产生小数，即排名一半
a = pd.Series([7, -5, 7, 4, 2, 0, 2])
a.rank()
0 ? ?6.5
1 ? ?1.0
2 ? ?6.5
3 ? ?5.0
4 ? ?3.5
5 ? ?2.0
6 ? ?3.5
dtype: float64
# 当有两个数据是一样的时候，利用method='first'会根据标签顺序继续进行排序
a = pd.Series([7, -5, 7, 4, 2, 0, 2])
a.rank(method='first')
?
0 ? ?6.0
1 ? ?1.0
2 ? ?7.0
3 ? ?5.0
4 ? ?3.0
5 ? ?2.0
6 ? ?4.0
dtype: float64

4.唯一值

利用unique()（返回唯一值的列表）

a = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
a.unique()
?
array(['c', 'a', 'd', 'b'], dtype=object)

利用nunique()（返回唯一值的个数）

a = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
a.nunique()
?
4

value_counts()获得唯一值和其唯一值对应出现的频数

a = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
a.value_counts()
?
c ? ?3
a ? ?3
b ? ?2
d ? ?1
dtype: int64

（DataFrame)观察多个列组合的唯一值，使用drop_duplicates(keep= '')以及duplicated()

这两者的区别在于后者返回值时返回的是布尔值，两者同时拥有一下三个参数的用法

keep参数后面可以接三个值：first,last,False

first：表示每一个组合保留第一次出现的位置（即行）

last：表示每一个组合保留最后一次出现的位置（即行）

False：表示把所有的重复组合所在行都去掉

5.替换函数

映射替换（repalce()）

（1）通过字典更换(两种方法)

s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s.replace({1:'a',2:'b'})
?
s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s.replace([1,2],['a','b'])
?
?
0 ? ?a
1 ? ?a
2 ? ?b
3 ? ?b
4 ? ?a
5 ? ?a
6 ? ?a
dtype: object

（2）指定方向替换（与前对齐，还是与后面对齐）

与前对齐

s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s.replace([1,2],method  = 'ffill')
?
0 ? ?a
1 ? ?a
2 ? ?b
3 ? ?b
4 ? ?b
5 ? ?b
6 ? ?a
dtype: object

与后对齐

s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s.replace([1,2],method  = 'bfill')
?
0 ? ?a
1 ? ?b
2 ? ?b
3 ? ?a
4 ? ?a
5 ? ?a
6 ? ?a
dtype: object

（3）正则替换(str.place)

逻辑替换（where,mask)

where()当不指定小于表示的值为多少时，它就会自动为缺失值，当指定后，它会为指定值（其中替换掉的不是满足表达式的值）

s = pd.Series([-1, 1,-2, 100, 6, 10, -3])
s.where(s<10)
s.where(s<10,False)
?
0 ? -1.0
1 ?  1.0
2 ? -2.0
3 ?  NaN
4 ?  6.0
5 ?  NaN
6 ? -3.0
dtype: float64
?
0 ? ? ? -1
1 ? ? ?  1
2 ? ? ? -2
3 ?  False
4 ? ? ?  6
5 ?  False
6 ? ? ? -3
dtype: object

mask()当不指定小于表示的值为多少时，它就会自动为缺失值，当指定后，它会为指定值（但是其中替换掉的是满足表达式的值）

s = pd.Series([-1, 1,-2, 100, 6, 10, -3])
print(s.mask(s<10))
print(s.mask(s<10,True))
?
0 ? ? ?NaN
1 ? ? ?NaN
2 ? ? ?NaN
3 ? ?100.0
4 ? ? ?NaN
5 ? ? 10.0
6 ? ? ?NaN
dtype: float64
 ? ?
0 ? ?True
1 ? ?True
2 ? ?True
3 ? ? 100
4 ? ?True
5 ? ? ?10
6 ? ?True
dtype: object

数值替换（round,abs,clip)

round()四舍五入，其中括号中填的值为小数后几位

s = pd.Series([-1.5, 1.234,-2.2654, 100, 6.2334, 10.5555, -3.6666])
s.round(2)
?
0 ? ? -1.50
1 ? ? ?1.23
2 ? ? -2.27
3 ? ?100.00
4 ? ? ?6.23
5 ? ? 10.56
6 ? ? -3.67
dtype: float64

abs()求其绝对值

s = pd.Series([-1.5, 1.234,-2.2654, 100, 6.2334, 10.5555, -3.6666])
s.abs()
?
0 ? ? ?1.5000
1 ? ? ?1.2340
2 ? ? ?2.2654
3 ? ?100.0000
4 ? ? ?6.2334
5 ? ? 10.5555
6 ? ? ?3.6666
dtype: float64

clip(2,3)表示其中的数在2，3这范围内的不变，在此之外的小于第一个数的不管有多小都会被替换为第一个数，大于第二个数的不管有多大，都会被替换为第二个数

s = pd.Series([-1.5, 1.234,-2.2654, 100, 6.2334, 10.5555, -3.6666])
s.clip(1,6)
?
0 ? ?1.000
1 ? ?1.234
2 ? ?1.000
3 ? ?6.000
4 ? ?6.000
5 ? ?6.000
6 ? ?1.000
dtype: float64

DataFrame

DataFrame是一个二维表格型数据结构。DataFrame对象既有行索引，又有列索引。其中，行索引表明不同行，横向索引。列索引表名不同列，纵向索引。（同时它可以被看做由Series组成的字典（共用同一个索引）

可以导入

from pandas import DataFrame as df

1.创建方式

（1）二维数组创建

a = df([[1,2,3],[4,5,6],[7,8,9]],index = list(['第一行','第二行','第三行']),columns = list(['第一列','第二列','第三列']))
a
?
 ? ? 第一列 第二列 第三列
第一行  1   ? ?2    3
第二行  4   ? ?5    6
第三行  7   ? ?8 ? ?9

（2）字典创建

a = df([[1,2,3],[4,5,6],[7,8,9]],index = list(['第一行','第二行','第三行']),columns = list(['第一列','第二列','第三列']))
a
?
 ? ? 第一列 第二列 第三列
第一行  1   ? ?2    3
第二行  4   ? ?5    6
第三行  7   ? ?8 ? ?9

2.DataFrame属性和操作

1 基础属性

(1)a.shape #行数和列数

(2)a.dtypes #列数据类型

(3)a.ndim #数据维度

(4)a.index #行索引

(5)a.columns #列索引

(6)a.values #对象值

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
 ? ? ? ?'year': [2000, 2001, 2002, 2001, 2002, 2003],
 ? ? ? ?'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
a = pd.DataFrame(data)
a.shape
a.dtypes
a.ndim
a.index
a.columns
a.values
?
?
(6, 3)
?
state ? ? object
year ? ? ? int64
pop ? ? ?float64
dtype: object
 
2
?
RangeIndex(start=0, stop=6, step=1)
?
Index(['state', 'year', 'pop'], dtype='object')
?
array([['Ohio', 2000, 1.5],
 ? ? ? ['Ohio', 2001, 1.7],
 ? ? ? ['Ohio', 2002, 3.6],
 ? ? ? ['Nevada', 2001, 2.4],
 ? ? ? ['Nevada', 2002, 2.9],
 ? ? ? ['Nevada', 2003, 3.2]], dtype=object)

2 基本操作

(1)a.head(3) #显示前3行

(2)a.tail(3) #显示末尾3行

(3)a.info() #显示信息概述，行数，列数，索引，列非空值个数，列类型等。

(4)a.describe() # 统计信息，均值，最大值，最小值，标准差等。

a.head(3)
a.tail(3)
a.info() 
a.describe() 
?
?
 ? state    year    pop
0   Ohio    2000    1.5
1   Ohio    2001    1.7
2   Ohio    2002    3.6
?
 ? state    year    pop
3   Nevada  2001    2.4
4   Nevada  2002    2.9
5   Nevada  2003    3.2
?
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 3 columns):
 # ? Column  Non-Null Count  Dtype ?
---  ------  --------------  ----- ?
 0 ? state ? 6 non-null ? ?  object 
 1 ? year ?  6 non-null ? ?  int64 ?
 2 ? pop ? ? 6 non-null ? ?  float64
dtypes: float64(1), int64(1), object(1)
memory usage: 272.0+ bytes
?
 ? ? ? ? ?  year    pop
count   6.000000    6.000000
mean    2001.500000 2.550000
std  ?  1.048809    0.836062
min  ?  2000.000000 1.500000
25%  ?  2001.000000 1.875000
50%  ?  2001.500000 2.650000
75%  ?  2002.000000 3.125000
max  ?  2003.000000 3.600000

3.索引

（1）根据索引值获取相对应的数据，并进行赋值

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)
a.index
a.values
a.columns
a['name']
a['name'] = '姓名'
?
?
RangeIndex(start=0, stop=3, step=1)
?
array([['小王', 22, 'man'],
 ? ? ? ['晓东', 21, 'man'],
 ? ? ? ['小敏', 20, 'woman']], dtype=object)
?
Index(['name', 'sage', 'ssex'], dtype='object')
?
0 ? ?小王
1 ? ?晓东
2 ? ?小敏
Name: name, dtype: object
 ? ? ? ?
    name    sage    ssex
0   姓名   ? ?22   ? man
1   姓名   ? ?21   ? man
2   姓名   ? ?20   ? woman

（2）标签索引 loc[]

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)
# 输出name列
a.loc[:,['name']] ? ? ? ? ? ? ? ?
# 输出第一行
a.loc[0]
# 输出name和sage
a.loc[0:,['name','sage']] ? # 等价于a.loc[:,['name','sage']]  a[['name','sage']]
?
    name
0   小王
1   晓东
2   小敏
?
name ? ? 小王
sage ? ? 22
ssex ? ?man
Name: 0, dtype: object
 ? ? ? ?
    name    sage
0   小王   ? 22
1   晓东   ? 21
2   小敏   ? 20

（3）位置索引 iloc[]

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)
#获取0号与1号同学的姓名和年龄
a.iloc[[0, 1] , [0, 1]] 
#获取每一位同学的姓名与年龄
a.iloc[0:,[0,2]]
?
    name    sage
0   小王   ? 22
1   晓东   ? 21
?
 ? ?name    ssex
0   小王   ? man
1   晓东   ? man
2   小敏   ? woman

（5）布尔索引

student={'name':['小王','晓东','小敏'，'小明'],
 ? ? ? ?'sage':[22,21,20,np.nan],
 ? ? ? ?'ssex':['man','man','woman','man']}
a = ?pd.DataFrame(student)
# 将大于等于21岁的人的年龄设置位True，否则就为False
a['sage'] <= 21
# 输出符合条件的人的信息
a[a['sage']<=21]
?
0 ? ?False
1 ? ? True
2 ? ? True
Name: sage, dtype: bool
 ? ? ? ?
 ? ?name    sage    ssex
1   晓东   ? 21    ?man
2   小敏   ? 20    ?woman
?
?
?
# 选择为空值的行
a[a['sage'].isnull()]
?
 ? ?name    sage    ssex
3   小明   ? NaN   ? man
?
?
?
#选择性别为男，年龄大于21的数据
a[(a['ssex'] == 'man') & (a['sage']>21)]
?
 ? ?name    sage    ssex
0   小王   ? 22.0  ? man
?
?
#选择年龄为21到22的人
a[a['sage'].between(21,22)]
?
    name    sage    ssex
0   小王   ? 22.0  ? ?man
1   晓东   ? 21.0     man

（6）对于具体的元素获得

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)
通过loc[]:

a.loc[0,'name']
a.loc[0,'ssex']
?
'小王'
'man'
通过iloc[]

a.iloc[0,0]
a.iloc[0,2]
?
'小王'
'man'

（7）删除相对应的数据

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)

通过 del（只能删除列）

del a['sage']
?
 ? ?name    ssex
0   小王   ? man
1   晓东   ? man
2   小敏   ? woman

通过函数drop()删除（只能一列或者一行一行的删）

# 按列删除
a.drop(['name'],axis = 1)
# 按行删除
a.drop([0])
#获取删除行后的值(最后得到的是一个数组)
a.drop(['name'],axis = 1).vaules
?
?
 ? sage ssex
0   22  man
1   21  man
2   20  woman
?
 ? name sage ssex
1   晓东  21  man
2   小敏  20  woman
?
array([[22, 'man'],
 ? ? ? [21, 'man'],
 ? ? ? [20, 'woman']], dtype=object)

（8）添加行

a.loc[3] = ['小王',22,'man']
a
?
    name    sage    ssex
0   姓名   ? 22   man
1   姓名   ? 21   man
2   姓名   ? 20   woman
3   小王   ? 22   man

（9）添加列（直接添加）

raw_data = {"name": ['Bulbasaur', 'Charmander','Squirtle','Caterpie'],
 ? ? ? ? ? ?"evolution": ['Ivysaur','Charmeleon','Wartortle','Metapod'],
 ? ? ? ? ? ?"type": ['grass', 'fire', 'water', 'bug'],
 ? ? ? ? ? ?"hp": [45, 39, 44, 45],
 ? ? ? ? ? ?"pokedex": ['yes', 'no','yes','no'] ? ? ? ? ? ? ? ? ? ? ? ?
 ? ? ? ? ?  }
a = pd.DataFrame(raw_data)
a['place'] =['park','street','lake','forest']
a
?
?
 ? ? ?name   ? evolution    type    hp  pokedex place
0   Bulbasaur   Ivysaur  ? grass    45   ?yes   park
1   Charmander  Charmeleon  fire    39   ?no    street
2   Squirtle    Wartortle   water   44   ?yes   lake
3   Caterpie    Metapod  ? ? bug    45   ?no    forest

（9）更改列的标签

利用rename

inplace：是否替换，默认为False。True表示在原DataFrame上修改，False将修改后的DataFrame作为新的对象返回

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)
a.rename(columns = {'name':"姓名",'sage':"年龄",'ssex':"性别"},inplace = True)
a
?
 ? ?姓名  年龄   性别
0   小王   22  ?man
1   晓东   21  ?man
2   小敏   20  ?woman

?
直接换（1）

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman']}
a = ?pd.DataFrame(student)
a.rename(columns = {'name':"姓名",'sage':"年龄",'ssex':"性别"},inplace = True)
a
?
 ? ?姓名  年龄   性别
0   小王   22  ?man
1   晓东   21  ?man
2   小敏   20  ?woman

直接换（2）

raw_data = {"name": ['Bulbasaur', 'Charmander','Squirtle','Caterpie'],
 ? ? ? ? ? ?"evolution": ['Ivysaur','Charmeleon','Wartortle','Metapod'],
 ? ? ? ? ? ?"type": ['grass', 'fire', 'water', 'bug'],
 ? ? ? ? ? ?"hp": [45, 39, 44, 45],
 ? ? ? ? ? ?"pokedex": ['yes', 'no','yes','no'] ? ? ? ? ? ? ? ? ? ? ? ?
 ? ? ? ? ?  }
a = pd.DataFrame(raw_data)
a = a[['name','type','hp','evolution','pokedex']]
a
?
v ? ? ? name     ? ?type    hp   ?evolution  ? ?pokedex
0    ?Bulbasaur  ? ?grass   45   ? Ivysaur   ? ? ?yes
1    ?Charmander    fire    39   ?Charmeleon     ? no
2    ?Squirtle   ? ?water   44   ?Wartortle  ? ? ? yes
3    ?Caterpie   ? ? bug    45   ? Metapod   ? ? ? no

（10）更改行的标签

reset_index()

其中的主要用法为一下内容：

drop: 重新设置索引后是否将原索引作为新的一列并入DataFrame，默认为False。

inplace: 是否在原DataFrame上改动，默认为False。True表示在原DataFrame上修改，False将修改后的DataFrame作为新的对象返回 level: 如果索引有多个列，仅从索引中删除level指定的列，默认删除所有列 col_level: 如果列名有多个级别，决定被删除的索引将插入哪个级别，默认插入第一级 col_fill: 如果列名有多个级别，决定其他级别如何命名

a = pd.Series(np.random.randint(1,5,100))
b = pd.Series(np.random.randint(1,4,100))
c = pd.Series(np.random.randint(1000,3001,100))
e = pd.concat([a,b,c],axis = 0)
e.reset_index(drop = True,inplace = True)
e
?
0 ? ? ? ? 3
1 ? ? ? ? 2
2 ? ? ? ? 2
3 ? ? ? ? 3
4 ? ? ? ? 2
 ? ? ? ... 
295 ? ?2715
296 ? ?2659
297 ? ?2979
298 ? ?2527
299 ? ?2469
Length: 300, dtype: int32

利用set_index()，

将列中的某一列设置为行标签

student={'name':['小王','晓东','小敏'],
 ? ? ? ?'sage':[22,21,20],
 ? ? ? ?'ssex':['man','man','woman'],
 ? ? ? ?'zimu':['a','b','c']}
a = pd.DataFrame(student)
a.set_index('zimu',inplace = True)
a
?
?
 ? ? ? ? ?name   sage   ssex
zimu            
a    ? ? ?小王    22   ? man
b    ? ? ?晓东    21   ? man
c    ? ? ?小敏    20   ? woman

（11）query()方法

此方法支持把字符串形式的查询表达式直接传入使用

4.合并操作

（1）使用concat，（合并时可以多个合并）

# 按列合并
?
a1 = pd.DataFrame([[1,2],[5,6]], #设置值
 ? ?index=list(['第一行','第二行']), ? ?#设行索引
 ? ?columns=list(['第一列','第二列'])) ?#列索引
?
a2 = pd.DataFrame([[9,10],[13,14]], #设置值
 ? ?index=list(['第一行','第二行']), ? ?#设行索引
 ? ?columns=list(['第三列','第四列'])) ?#列索引 ? 在这里也可以将第三列和第四列该为第一列和第二列，一样的也是加在后面
s = pd.concat([a1, a2], axis=1) 
print(s)
?
?
第一列 ?第二列 ?第三列 ?第四列
第一行 ? ?1 ? ?2 ? ?9 ? 10
第二行 ? ?5 ? ?6 ? 13 ? 14

# 按行合并
a1 = pd.DataFrame([[1,2],[5,6]], #设置值
 ? ?index=list(['第一行','第二行']), ? ?#设行索引
 ? ?columns=list(['第一列','第二列'])) ?#列索引
?
a2 = pd.DataFrame([[9,10],[13,14]], #设置值
 ? ?index=list(['第一行','第二行']), ? ?#设行索引
 ? ?columns=list(['第一列','第二列'])) ?#列索引  如果将这里的第一列和第二列改为第三列和第四列，则结果完全不同
s = pd.concat([a1, a2], axis=1) 
print(s)
?
 ? ?第一列 ?第二列
第一行 ? ?1 ? ?2
第二行 ? ?5 ? ?6
第一行 ? ?9 ? 10
第二行 ? 13 ? 14
?
 第一列 ?第二列 ? 第三列 ? 第四列
第一行 ?1.0 ?2.0 ? NaN ? NaN
第二行 ?5.0 ?6.0 ? NaN ? NaN
第一行 ?NaN ?NaN ? 9.0 ?10.0
第二行 ?NaN ?NaN ?13.0 ?14.0

（2）通过merge合并

a1 = DataFrame([[1,2],[5,6]], #设置值
 ? ?index=list(['第一行','第二行']), ? ?#设行索引
 ? ?columns=list(['第一列','第二列'])) ?#列索引
?
a2 = DataFrame([[2,5],[3,8]], #设置值
 ? ?index=list(['第一行','第二行']), ? ?#设行索引
 ? ?columns=list(['第三列','第四列'])) ?#列索引

#(1)默认的为交集inner

a1.merge(a2,left_on="第二列",right_on='第三列',how= 'inner')
#等价于pd.merge(a1,a2,left_on="第二列",right_on='第三列',how= 'inner')
?
(2,6) & (2,3) = 2

输出：
 ? 第一列 ?第二列 ?第三列 ?第四列
0 ? ? 1 ? ? ? 2 ? ? ? 2 ? ? ? 5

#（2）并集outer，NaN补全
a1.merge(a2,left_on="第二列",right_on='第三列',how= 'outer')
?
(2,6) | (2,3) = (2,3,6)

输出：
 第一列 ?第二列 ?第三列 ?第四列
0 ? 1.0 ? ?2.0 ? ? 2.0 ? ? 5.0
1 ? 5.0 ? ?6.0 ? ? NaN ? ? NaN
2 ? NaN ? ?NaN ? ? 3.0 ? ? 8.0

# (3)以左边为准left，NaN补全（左边全部输出，如果右边有交集则输出，否则就输出为空值）
a1.merge(a2,left_on="第二列",right_on='第三列',how= 'left')
?
 ? 第一列 ?第二列 ?第三列 ?第四列
0 ? ?1 ? ? ? ?2 ? ? ?2.0 ? ? 5.0
1 ? ?5 ? ? ? ?6 ? ? ?NaN ? ? NaN

# (4)以右边为准right，NaN补全（右边全部输出，如果左边有交集同样会输出整行，否则输出也为空值）
a1.merge(a2,left_on="第二列",right_on='第三列',how= 'right')
?
 ? 第一列 ?第二列 ?第三列 ?第四列
0 ? ?1.0 ? ? 2.0 ? ? ?2 ? ? ? 5
1 ? ?NaN ? ? NaN ? ? ?3 ? ? ? 8

#（5）如果两个列表中出现了重复的列名，那么可以通过suffixes参数指定。
f1 = pd.DataFrame({'Name':['San Zhang'],'Grade':[70]})
f2 = pd.DataFrame({'Name':['San Zhang'],'Grade':[80]})
df1.merge(df2, on='Name', how='left', suffixes=['_Chinese','_Math'])
?
     ? ? Name    ? ? ?Grade_Chinese  ? Grade_Math
0 ? ? ?San Zhang     ? ? ? 70    ? ? ? ? ? 80

（3）当想把一个序列加到一个表的行末或者列末则可以分别使用append()和assign()方法

append()

f1 = pd.DataFrame({'Name':['San Zhang','Si Li'], 'Age':[20,21]})
s = pd.Series(['Wu Wang', 21], index = f1.columns)
f1.append(s, ignore_index=True)
?
?
 ? ? ? ?Name     ? ? Age
0    ?San Zhang  ? ? ?20
1    ? ?Si Li    ? ? ?21
2    ? Wu Wang   ? ? ?21

assign()

s = pd.Series([80, 90])
f1.assign(Grade=s)
?
?
 ? ? ?Name   ? ? Age    Grade
0   San Zhang    20  ? ? 80
1    Si Li   ? ? 21  ? ? 90

(4）比较不同，输出不同的compare()

a1 = pd.DataFrame({'Name':['San Zhang', 'Si Li', 'Wu Wang'],
 ? ? ? ? ? ? ? ? ? ?'Age':[20, 21 ,21],
 ? ? ? ? ? ? ? ? ? ?'Class':['one', 'two', 'three']})
a2 = pd.DataFrame({'Name':['San Zhang', 'Li Si', 'Wu Wang'],
 ? ? ? ? ? ? ? ? ? ?'Age':[20, 21 ,21],
 ? ? ? ? ? ? ? ? ? ?'Class':['one', 'two', 'Three']})
a1.compare(a2)
?
     ? ?Name     ? ? ? ?Class
 ? ?self    other   self    other
1   Si Li   Li Si    NaN ? ? ?NaN
2   NaN  ? ? NaN    three   Three

如果想要完整的显示表中所有元素的比较情况，可以设置keep_shape = True

a1.compare(a2,keep_shape = True)
?
?
 ? ? ? ? Name    ? ? ? ? ? ? Age     ? ? ? ? ? ?Class
 ? ?self    other    ? ?self    other    ? ?self    other
0   NaN ? ? ?NaN     ? ?NaN  ? ? NaN     ? ? NaN    NaN
1   Si Li   Li Si    ? ?NaN  ? ? NaN     ? ? NaN    NaN
2   NaN  ? ? NaN     ? ?NaN  ? ? NaN     ? three    Three

（5）组合

5.统计操作

（1）常用统计函数

统计出现的次数

# 统计动物出现的次数
data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],
 ? ? ? ?'age': [2.5, 3, 0.5, np.nan, 5, 2, 4.5, np.nan, 7, 3],
 ? ? ? ?'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
 ? ? ? ?'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}
?
labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
?
df =pd.DataFrame(data,index = labels)
df['animal'].value_counts()
?
dog ? ? ?4
cat ? ? ?4
snake ? ?2
Name: animal, dtype: int64

（2）相关性统计分析

? 协方差>0,X和Y正相关

? 协方差<0,X和Y负相关

? 协方差=0,X和Y独立无关

df = df({ ?"A":[5, 3, 6, 4], ?
 ? ? ? ? "B":[11, 2, 4, 3], 
 ? ? ? ? "C":[4, 3, 8, 5], 
 ? ? ? ? "D":[5, 4, 2, 8]})
df.cov()
?
 A ? ? ? ? ?B ? ? ? ? C ? ? ? ? ?D
A ?1.666667 ? 2.333333 ? ?2.333333 ? ?-1.500000
B ?2.333333 ? 16.666667 ? -1.000000 ? 0.000000
C ?2.333333 ? -1.000000 ? 4.666667 ? ?-2.333333
D -1.500000 ? ?0.000000 ? -2.333333 ? ?6.250000

6.apply方法

apply方法就是将匿名函数应用到由列或行形成的一维数组上。可以快速的处理数据，很方便。

import pandas as pd
?
a=pd.DataFrame(np.random.randint(0,5,(5,5)),columns=list('abcde'))
# 求每列的最大值与最小值的差
x = a.apply(lambda x:x.max()-x.min())
# 求每行的最大值与最小值的差
y = a.apply(lambda x:x.max()-x.min(), axis=1)
print(x,y)
?
a ? ?4
b ? ?3
c ? ?4
d ? ?4
e ? ?4
dtype: int64 0 ? ?1
1 ? ?4
2 ? ?3
3 ? ?2
4 ? ?4
dtype: int64

（1）创建函数将字符串的第一个字母大写,以下为函数，直接用apply()直接调用

capitalizer = lambda x: x.capitalize()
#apply(capitalizer )

（2）applymap

applymap()会对DataFrame中的每一个单元格进行指定的函数操作,用法很简单，以下为具体用法：

def c(x):
 ? ?if type(x) is int:
 ? ? ? ?return x*10
 ? ?else:
 ? ? ? ?return x
 ? ? ? ?
a.applymap(c).head(10)

7.分组（利用groupby())

一般的方式为：df.groupby(分组依据)[数据来源].使用操作

GroupBy技术是对于数据进行分组计算并将各组计算结果合并的一项技术，它一般分为三个过程：

（1）拆分：将数据进行相对应的分组

（2）应用：通过函数的调用将每一个数据进行处理

（3）合并：将计算的结果进行数据聚合

一般用法：

访问data1的数据并按照key1进行分组

 df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'],
 ? ? ? ? ? ? ? ? ? ?'key2' : ['one', 'two', 'one', 'two', 'one'],
 ? ? ? ? ? ? ? ? ? 'data1' : np.random.randn(5),
 ? ? ? ? ? ? ? ? ? 'data2' : np.random.randn(5)})
a = df['data1'].groupby(df['key1'])
a.mean()
#以上等价于下面两个
#df['data1'].groupby(df['key1']).mean()
#df.groupby('key1')['data1'].mean()
?
key1
a ? -0.608341
b ? -0.287105
Name: data1, dtype: float64


student = pd.DataFrame(  [['A', 'male',95,79],
 ? ? ? ? ? ? ?  ['A', 'female',96,90],
 ? ? ? ? ? ? ?  ['B', 'female',85,85],
 ? ? ? ? ? ? ?  ['C', 'male',93,92],
 ? ? ? ? ? ? ?  ['B', 'female',84,90],
 ? ? ? ? ? ? ?  ['B', 'male',88,70],
 ? ? ? ? ? ? ?  ['C', 'male',59,89],
 ? ? ? ? ? ? ?  ['A', 'male', 89,86],
 ? ? ? ? ? ? ?  ['B', 'male',89,74]], ? ?
 ? ?columns=list(['班级','性别','数学','语文'])) ?#列索引
a = student
a.groupby(['班级','性别']).mean()
?
?
     ? ? ? ?数学  语文
?
班级  性别      
A   female  96.0    90.0
 ? ?male    92.0    82.5
B   female  84.5    87.5
 ? ?male    88.5    72.0
C   male    76.0    90.5

8.函数用法

（1）agg为聚合函数，一般在数据分组之后对数据进行多重处理，比如：求平均值后求最大最小值

a = pd.DataFrame({'Country': ['China', 'China', 'India', 'India', 'America', 'Japan', 'China', 'India'],
?
 ? ? ? ? ? ? ? ? ? 'Income': [10000, 10000, 5000, 5002, 40000, 50000, 8000, 5000],
?
 ? ? ? ? ? ? ? ? ? 'Age': [5000, 4321, 1234, 4010, 250, 250, 4500, 4321]})
?
a.groupby('Country').Age.agg(['mean','max','min'])
?
?
 ?
 ? ? ? ? ? ?mean     ? ? ? ? max    min
Country         
America  250.000000  ? ? 250    250
China    4607.000000     5000   4321
India    3188.333333     4321   1234
Japan    250.000000  ? ? 250    250

（2）transform方法

9.数据排序

（1）sort_index()：对行和列进行排序（都是对标签进行排序）

a = pd.DataFrame([[1,2,3,4],
 ? ? ? ? ? ? ? ?  [5,1,1,1],
 ? ? ? ? ? ? ? ?  [2,3,7,8],
 ? ? ? ? ? ? ? ?  [7,6,8,5]],
 ? ? ? ? ? ? ? ?index = ['b','d','a','c'],
 ? ? ? ? ? ? ? ?columns = ['x','z','y','m'])
#对行标签进行排序
a.sort_index()
#对列标签进行排序
a.sort_index(axis = 1)
#对列标签进行排序，排序方式为逆序
a.sort_index(axis=1,ascending=False)
?
?
 ? ?x   z   y   m
a   2   3   7   8
b   1   2   3   4
c   7   6   8   5
d   5   1   1   1
?
 ? ?m   x   y   z
b   4   1   3   2
d   1   5   1   1
a   8   2   7   3
c   5   7   8   6
?
 ? ?z   y   x   m
b   2   3   1   4
d   1   1   5   1
a   3   7   2   8
c   6   8   7   5

（2）sort_values()，只能由列进行排序

a = pd.DataFrame([[1,2,3,4],
 ? ? ? ? ? ? ? ?  [5,1,1,1],
 ? ? ? ? ? ? ? ?  [2,3,7,8],
 ? ? ? ? ? ? ? ?  [7,6,8,5]],
 ? ? ? ? ? ? ? ?index = ['b','d','a','c'],
 ? ? ? ? ? ? ? ?columns = ['x','z','y','m'])
# 以下两种没什么区别
a.sort_values(by='z')
a.sort_vlaues(by=['z','x'])
?
 ? ?x   z   y   m
d   5   1   1   1
b   1   2   3   4
a   2   3   7   8
c   7   6   8   5
?
    x   z   y   m
d   5   1   1   1
b   1   2   3   4
a   2   3   7   8
c   7   6   8   5  

（3）两者都用ascending来对排序的方式进行确定

# 升序
ascending = True
# 降序
ascending = False

10.字符串操作

例：

a = pd.DataFrame( ? ? [['101', '东','16:30'],
 ? ? ? ? ? ? ?  ['102', '南','16:30'],
 ? ? ? ? ? ? ?  ['103', '南','16:30'],
 ? ? ? ? ? ? ?  ['104', '北','16:30'],
 ? ? ? ? ? ? ?  ['105', '东','16:30'],
 ? ? ? ? ? ? ?  ['106', '西','16:30'],
 ? ? ? ? ? ? ?  ['107', '西','16:30'],
 ? ? ? ? ? ? ?  ['108', '南', '16:30'],
 ? ? ? ? ? ? ?  ['109', '东','16:30']], ? ?
 ? ? ? ? ? ? ? ?columns=list(['房号','房屋朝向','时间']))
# 选择房屋朝向的东和南方向
str = ['东','南']
a1 = a[a['房屋朝向'].isin(str)]
a1
?
 ? ?房号  房屋朝向 ?时间
0   101 ? ?东    16:30
1   102  ? 南    16:30
2   103  ? 南    16:30
4   105 ? ?东    16:30
7   108  ? 南    16:30
8   109  ? 东    16:30
 ? ?
 ? ?
#将房屋朝向的四个方向用1，2，3，4更换
fx = {"东":1,"西":2,"南":3,"北":4}
a['房屋朝向'] = a.房屋朝向.map(fx)
a
?
?
 ? ?房号   房屋朝向   时间
0   101  ? ?1    ? 16:30
1   102  ? ?3    ? 16:30
2   103 ? ? 3    ? 16:30
3   104  ? ?4    ? 16:30
4   105 ? ? 1    ? 16:30
5   106  ? ?2    ? 16:30
6   107  ? ?2    ? 16:30
7   108  ? ?3    ? 16:30
8   109  ? ?1    ?16:30

时间字符串转化时间格式：

(1)to_datetime将字符串格式转换为日期格式

a['时间'] =pd.to_datetime(a['时间'],format='%H:%M') 
?
?
 ? ?房号  房屋朝向    时间
0   101  ? ?1   1900-01-01 16:30:00
1   102  ? ?3   1900-01-01 16:30:00
2   103     3   1900-01-01 16:30:00
3   104     4   1900-01-01 16:30:00
4   105     1   1900-01-01 16:30:00
5   106     2   1900-01-01 16:30:00
6   107     2   1900-01-01 16:30:00
7   108     3   1900-01-01 16:30:00
8   109     1   1900-01-01 16:30:00

(2) strptime将字符串格式转换为日期格式

from datetime import datetime
?
a['时间']= a['时间'].apply(lambda x:datetime.strptime(x,'%H:%M')) 
?
    房号  房屋朝向    时间
0   101     1   1900-01-01 16:30:00
1   102     3   1900-01-01 16:30:00
2   103     3   1900-01-01 16:30:00
3   104     4   1900-01-01 16:30:00
4   105     1   1900-01-01 16:30:00
5   106     2   1900-01-01 16:30:00
6   107     2   1900-01-01 16:30:00
7   108     3   1900-01-01 16:30:00
8   109     1   1900-01-01 16:30:00

(3)strftime将日期格式转换为字符串格式（转回）

from datetime import datetime
?
a['时间']= a['时间'].apply(lambda x:datetime.strftime(x,'%H-%M'))
?
    房号  房屋朝向    时间
0   101     1    ? 16-30
1   102     3    ? 16-30
2   103     3    ? 16-30
3   104     4    ? 16-30
4   105     1    ? 16-30
5   106     2    ? 16-30
6   107     2    ? 16-30
7   108     3    ? 16-30
8   109     1    ? 16-30

11.文件操作

（1）文件读取

pd.read_csv(filepath, sep=',', delimiter=None, header='infer', names=None, index_col=None, prefix=None, nrows=None, encoding=None, skiprows=0)

常见参数如下：

(1)filepath：文件所在处的路径

(2)sep：指定分隔符，默认为逗号’,’

(2)delimiter : str, default None定界符，备选分隔符（如果指定该参数，则sep参数失效）

(3)header：指定哪一行作为表头。默认设置为0（即第一行作为表头），如果没有表头的话，要修改参数，设置header=None

(4)names：指定列的名称，用列表表示。一般我们没有表头，即header=None时，这个用来添加列名就很有用啦。

(5)index_col:指定哪一列数据作为行索引，可以是一列，也可以多列。多列的话，会看到一个分层索引

(6)prefix:给列名添加前缀。如prefix="x",会出来"x1"、"x2"、"x3"

(7)nrows : 需要读取的行数（从文件头开始算起）

(8)encoding:乱码的时候用这个就是了

(9)skiprows :忽略的行数（从文件开始处算起），或需要跳过的行号列表（从0开始）。

（2）保存文件

to_csv(path,sep,na_rep,columns,header,index)

参数解析：

(1)path：字符串，放文件名、相对路径、文件流等。

(2)sep：字符串，分隔符，跟read_csv()的一个意思。

(3)na_rep：字符串，将NaN转换为特定值。

(4)columns：列表，指定哪些列写进去。

(5)header：默认header=0，表示有表头；header= None，表示没有表头。

(6)index：默认True，设置表格有索引；False，设置表格没有索引。

例如：

import numpy as np

df = pd.DataFrame({"a":[1,2,3],

"b":[6,np.nan,6],

"c":[3,4,np.nan]})

df.to_csv(path)

df.to_csv(path,header=None)

df.to_csv(path, columns=["a","c"],index=False)

df.to_csv(path, na_rep=0)

（3）按格式输出

DataFrame.to_html("test.html")

12.行列反转

stack()即“堆叠”，作用是将列旋转到行 unstack()即stack()的反操作，将行旋转到列

具体用法：

a= pd.DataFrame(np.arange(6).reshape((2, 3)),
 ? ? ? ? ? ? ? ? ? ?index=pd.Index(['Ohio', 'Colorado']),
 ? ? ? ? ? ? ? ? ? ?columns=pd.Index(['one', 'two', 'three']))
print(a)
print()
print()
print(a.stack())
print()
print()
print(a.unstack())
?
?
?
 one ?two ?three
Ohio ? ? ? ?0 ? ?1 ? ? ?2
Colorado ? ?3 ? ?4 ? ? ?5
?
?
Ohio ? ? ?one ? ? ?0
 ? ? ? ? ?two ? ? ?1
 ? ? ? ? ?three ? ?2
Colorado ?one ? ? ?3
 ? ? ? ? ?two ? ? ?4
 ? ? ? ? ?three ? ?5
dtype: int32
?
?
one ? ?Ohio ? ? ? ?0
 ? ? ? Colorado ? ?3
two ? ?Ohio ? ? ? ?1
 ? ? ? Colorado ? ?4
three ?Ohio ? ? ? ?2
 ? ? ? Colorado ? ?5
dtype: int32

直接行列互换.T（相当于矩阵的转置）

df = pd.DataFrame(data = {'col_0': [1,2,3],
 ? ? ? ? ? ? ? ? ? ? ? ? ?'col_1':list('abc'),
 ? ? ? ? ? ? ? ? ? ? ? ? ?'col_2': [1.2, 2.2, 3.2]},
 ? ? ? ? ? ? ? ? ?index = ['row_%d'%i for i in range(3)])
df
?
df.T
?
?
     ? col_0    col_1   col_2
row_0    1   ? ? ?a  ? ? 1.2
row_1    2   ? ? ?b  ? ? 2.2
row_2    3   ? ? ?c ? ? ?3.2
?
 ? ? ? row_0    row_1   row_2
col_0    ? 1     ? 2    3
col_1    ? a     ? b    c
col_2    ?1.2    ?2.2   3.2

13.长表变宽表(pivot)

df = pd.DataFrame({'Class':[1,1,2,2],
 ? ? ? ? ? ? ? ? ? 'Name':['San Zhang','San Zhang','Si Li','Si Li'],
 ? ? ? ? ? ? ? ? ? 'Subject':['Chinese','Math','Chinese','Math'],
 ? ? ? ? ? ? ? ? ? 'Grade':[80,75,90,85]})
df
df.pivot(index = 'Name',columns = 'Subject',values = 'Grade')
?
?
 ? Class    Name     ? Subject   Grade
0   1    ? San Zhang    Chinese  ?80
1   1    ? San Zhang    Math     ?75
2   2    ? Si Li     ? Chinese   ?90
3   2    ? Si Li     ? ?Math     ?85
?
Subject  ?Chinese   Math
Name        
San Zhang   80   ? ? ?75
Si Li    ? ?90   ? ? ?85

14.缺失值

（1）缺失信息的统计isna()和isnull()，查看表格中是否有缺失值

这两个方法的使用后输出的结果都是一样的

raw_data = {"name": ['Bulbasaur', np.nan,'Squirtle','Caterpie'],
 ? ? ? ? ? ?"evolution": ['Ivysaur','Charmeleon','Wartortle','Metapod'],
 ? ? ? ? ? ?"type": ['grass', 'fire', 'water', 'bug'],
 ? ? ? ? ? ?"hp": [45, np.nan, 44, 45],
 ? ? ? ? ? ?"pokedex": ['yes', 'no',np.nan,'no'] ? ? ? ? ? ? ? ? ? ? ? ?
 ? ? ? ? ?  }
a = pd.DataFrame(raw_data)
a.isna()
a.isnull()
?
    name    evolution   type     hp     pokedex
0   False   False    ? False    False    False
1   True    False    ? False    True     False
2   False   False    ? False    False    True
3   False   False    ? False    False    False

（2）两个方法检索all(1),any(1),与isna()和notna()组合

举一例

raw_data = {"name": ['Bulbasaur', np.nan,'Squirtle','Caterpie'],
 ? ? ? ? ? ?"evolution": ['Ivysaur','Charmeleon','Wartortle','Metapod'],
 ? ? ? ? ? ?"type": ['grass', 'fire', 'water', 'bug'],
 ? ? ? ? ? ?"hp": [np.nan, np.nan, np.nan, 15],
 ? ? ? ? ? ?"pokedex": ['yes', 'no',np.nan,'no'] ? ? ? ? ? ? ? ? ? ? ? ?
 ? ? ? ? ?  }
a = pd.DataFrame(raw_data)
a[a.notna().all(1)]
?
    name     ? evolution    type     ?hp    pokedex
3   Caterpie    Metapod  ? ? bug     15.0    ?no

以上是对于我做数据分析时所遇到的一些pandas操作，后续会继续往里面添加。