DataFrame相关常用操作（备忘、随时补充）：

series:

Series 是一个一维数组对象 ，类似于 NumPy 的一维 array。它除了包含一组数据还包含一组索引，所以可以把它理解为一组带索引的数组。

创建：

创建一个简单的series实例：

1
2
3
4
import pandas as pd
a = [1, 2, 3]
myser = pd.Series(a)
print(myser)

运行结果为：

1
2
3
4
0    1
1    2
2    3
dtype: int64

左侧为索引，右侧为数据，下方显示数据类型int64。当没有显示指定索引的时候，Series 自动以 0 开始，步长为 1 为数据创建索引。

通过字典创建：

1
2
3
4
5
import pandas as pd
sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myser = pd.Series(sites)
print(myser)
print(myser[2])

也可以设置index来选择哪几行被创建进series，设置name来设置名称：

1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd
sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myser = pd.Series(sites,index=[1,2],name='hello')
print(myser)
print(myser[2])

'''
1    Google
2    Runoob
Name: hello, dtype: object
Runoob
'''

想要单独获取 Series 对象的索引或者数组内容的时候，可以使用 index 和 values 属性，例如：

1
2
3
4
5
6
7
8
9
10
import pandas as pd
sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myser = pd.Series(sites,index=[1,2],name='hello')
print(myser.index)
print(myser.values)

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

读取：

根据索引读取内容：

1
2
3
4
import pandas as pd
a = [1, 2, 3]
myser = pd.Series(a)
print(myser[1])

指定索引名称并通过指定的名称读取：

1
2
3
4
5
import pandas as pd
a = [1, 2, 3]
myser = pd.Series(a,index=['x','y','z'])
print(myser)
print(myser['z'])

赋值：

单独赋值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd
sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myser = pd.Series(sites,index=[1,2])
print(myser)
myser[2]='baidu'
print(myser) 

'''
1    Google
2    Runoob
dtype: object
1    Google
2     baidu
dtype: object
'''

对Series对象运算：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pandas as pd
sites = {1: 10, 2: 20, 3: 30}
myser = pd.Series(sites)
print(myser)
print(myser * 2)
print(myser * 2 + 1)
print(myser[myser > 15])

'''
1    10
2    20
3    30
dtype: int64
1    20
2    40
3    60
dtype: int64
1    21
2    41
3    61
dtype: int64
2    20
3    30
dtype: int64
'''

转化为列表list：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
sites = {1: 10, 2: 20, 3: 30}
myser = pd.Series(sites)
print(myser)
print(myser.values.tolist())
print(myser.tolist())
print(list(myser))

'''
1    10
2    20
3    30
dtype: int64
[10, 20, 30]
[10, 20, 30]
[10, 20, 30]
'''

series如果需要改变数据类型，for循环一个个改会导致一些问题，最好一列一起改。

DataFrame

DataFrame 是一个表格型的数据结构。它提供有序的列和不同类型的列值。

创建：

例如将一个由 NumPy 数组组成的字典转换成 DataFrame 对象（ndarray 的长度必须相同， 如果传递了 index，则索引的长度应等于数组的长度。如果没有传递索引，则默认情况下，索引将是range(n)，其中n是数组长度）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd

data = {
    "name": ["Carl", "Peter", "Lucy", "Jobs"],
    "age": [30, 40, 20, 33],
    "gender": ["m", "m", "f", "f"],
}
frame = pd.DataFrame(data)
print(frame)

'''
    name  age gender
0   Carl   30      m
1  Peter   40      m
2   Lucy   20      f
3   Jobs   33      f
'''

想要指定列的顺序？传入一个列名的list即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd

data = {
    "name": ["Carl", "Peter", "Lucy", "Jobs"],
    "age": [30, 40, 20, 33],
    "gender": ["m", "m", "f", "f"],
}
frame = pd.DataFrame(data, columns=["age", "name", "gender"])
print(frame)

'''
   age   name gender
0   30   Carl      m
1   40  Peter      m
2   20   Lucy      f
3   33   Jobs      f
'''

如果传入的列名找不到，它不会报错，而是产生一列 NaN 值

DataFrame 也可以列表的形式创建：

1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd

data = [["Google", 10], ["Runoob", 12], ["Wiki", 13]]
df = pd.DataFrame(data, columns=["Site", "Age"], dtype=float)
print(df)

'''
     Site   Age
0  Google  10.0
1  Runoob  12.0
2    Wiki  13.0
'''

还可以使用字典（key/value），其中字典的 key 为列名，没有对应的部分数据为 NaN。:

1
2
3
4
5
6
7
8
9
10
11
import pandas as pd

data = [{"a": 1, "b": 2}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df)

'''
   a   b     c
0  1   2   NaN
1  5  10  20.0
'''

我们可以指定索引值，如下实例：

1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd

data = {"calories": [420, 380, 390], "duration": [50, 40, 45]}
df = pd.DataFrame(data, index=["day1", "day2", "day3"])
print(df)

'''
      calories  duration
day1       420        50
day2       380        40
day3       390        45
'''

DataFrame 某列不仅可以以字典索引的方式获取数据，还可以以属性的方法获取，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df)
print(df.a)
print(df['b'])

'''
   a   b   c
0  1   2   3
1  5  10  20
0    1
1    5
Name: a, dtype: int64
0     2
1    10
Name: b, dtype: int64
'''

修改、删除某一列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df)
df.c=0
print(df)
del df['c'] # 这里不能用 df.c
print(df)

'''
   a   b   c
0  1   2   3
1  5  10  20
   a   b  c
0  1   2  0
1  5  10  0
   a   b
0  1   2
1  5  10
'''

读取

df[['a']] 和 df['a']都能读取第一列数据，但它们的返回结果是不同的：

<class ‘pandas.core.frame.DataFrame’>

<class ‘pandas.core.series.Series’> 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df , "\n")
print(df[["a"]] , "\n")
print(df["a"] , "\n")

'''
   a   b   c
0  1   2   3
1  5  10  20 

   a
0  1
1  5 

0    1
1    5
Name: a, dtype: int64 
'''

读取单元格时：df[col][row]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df , "\n")
print(df['a'][1])
print(df.b[0])

'''
   a   b   c
0  1   2   3
1  5  10  20 

5
2
'''

Pandas 可以使用 loc 属性返回指定行的数据，如果没有设置索引，第一行索引为0，第二行索引为1，以此类推：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd

data = {"calories": [420, 380, 390], "duration": [50, 40, 45]}

# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)

# 返回第一行
print(df.loc[0])
# 返回第二行
print(df.loc[1])
# 返回第一行第一个
print(df.loc[0].calories)

'''
calories    420
duration     50
Name: 0, dtype: int64
calories    380
duration     40
Name: 1, dtype: int64
420
'''

注意：返回结果其实就是一个 Pandas Series 数据。

也可以返回多行数据，使用loc [[ … ]] 格式，… 为各行的索引，以逗号隔开：

1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd

data = {"calories": [420, 380, 390], "duration": [50, 40, 45]}
df = pd.DataFrame(data)
# 返回第一、二行
print(df.loc[[0,1]])

'''
   calories  duration
0       420        50
1       380        40
'''

读取多行多列 .loc ：

df.loc[[row1,row2],[col1,col2]]

df.loc[[row1,row2]][[col1,col2]]

df.loc[[ row1 , row3 ], firstCol : endCol]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df , "\n")
print(df.loc[[0,1]][['a','b']],'\n')
print(df.loc[[1,0],['a','b']])
print(df.loc[[1,0],'a':'c']) # 注意，行不允许切片，列可以

'''
   a   b   c
0  1   2   3
1  5  10  20 

   a   b
0  1   2
1  5  10 

   a   b
1  5  10
0  1   2

   a   b   c
1  5  10  20
0  1   2   3
'''

有时候我们可能更希望通过列号/行号（1，2，3…）读取数据而不是列名，又或着我们要读取多行的时候一个一个输入列名是很麻烦的，.iloc方法可以让我们通过列号索引数据，具体如下：

df.iloc[:,:1]读取第一列

df.iloc[:,1:3]读取第1列到第3列

df.iloc[:,2:]读取第2列之后的数据

df.iloc[:,:3]读取前3列数据

.iloc同样可以读取行号

.iloc[‘行号’]

.iloc[[‘行号’]]

.iloc[[‘行号1’,’行号2’,’行号n’]]

.iloc根据行号索引数据，行号是固定不变的，不受索引变化的影响，如果df的索引是默认值，则.loc和.iloc的用法没有区别，因为此时行号和行标签相同。如果从第0行开始读，则首位置可以省略，如果从某一行读到末尾，则尾位置可以省略。

df.iloc[:5]，读取第0行到第4行的数据；

df.iloc[8:]，读取第8行后所有数据，包括第8行；

df.iloc[3:6]，读取第3行到第6行的数据，包括第3行但不包括第6行。

df.iloc[0,1]，读取第0行第一列第数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df , "\n")
print(df.loc[[0,1]].iloc[:,2])
print(df.loc[[1]].iloc[:,2])
print(df.loc[[1]].iloc[0,2])

'''
   a   b   c
0  1   2   3
1  5  10  20 

0     3
1    20
Name: c, dtype: int64

1    20
Name: c, dtype: int64

20

'''

.ix的使用：link

对于一个pd.DataFrame，df.head(10)可以返回前10行，df.tail(10)可以返回最后10行。

一个画图常用的index的设置方法：

1.set_index

DataFrame可以通过set_index方法，可以设置单索引和复合索引。
DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
append添加新索引，drop为False，inplace为True时，索引将会还原为列。

2.reset_index
reset_index可以还原索引，重新变为默认的整型索引
DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill=”)
level控制了具体要还原的那个等级的索引
drop为False则索引列会被还原为普通列，否则会丢失

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pandas as pd

df7 = pd.DataFrame({'a': 1, 'b': 2}, index=[0])
df7.loc[1] = [3, 4]
print(df7)
df7.set_index('a', inplace=True)
print(df7)
df7.reset_index(inplace=True)
print(df7)

   a  b
0  1  2
1  3  4
   b
a   
1  2
3  4
   a  b
0  1  2
1  3  4

3.reindex

•使用reindex方法重新排序和指定索引，会根据新索引重排数据

1
2
3
4
5
6
7
8
>>> students.reindex(index=['1850005','1850004','1850002','1850001',  
'1850003'],columns=['姓名','性别','专业','成绩'])
          姓名 性别    专业        成绩
1850005   王丹  女    金融学        67
1850004   李明  男    交通工程   54
1850002   段霞  女    金融学       88
1850001   张海  男    交通工程   90
1850003 敬卫华  男   土木工程  91

DF对象的常用属性：

1
2
3
4
5
6
7
8
import pandas as pd

a = pd.DataFrame({"one": pd.Series([1, 2, 3],index=['a','b','c']), "two": [4, 5, 6]})
print(a.T)
print(a.index)
print(a.columns)
print(a.values)
print(a.describe())

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
     a  b  c
one  1  2  3
two  4  5  6
Index(['a', 'b', 'c'], dtype='object')
Index(['one', 'two'], dtype='object')
[[1 4]
 [2 5]
 [3 6]]
       one  two
count  3.0  3.0
mean   2.0  5.0
std    1.0  1.0
min    1.0  4.0
25%    1.5  4.5
50%    2.0  5.0
75%    2.5  5.5
max    3.0  6.0

赋值操作：

按列赋值：

如果用一个列表或数组赋值，其长度必须和df的行数相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df , "\n")
df.a=[33,44]
print(df , "\n")
df['b']=0
print(df , "\n")

'''
   a   b   c
0  1   2   3
1  5  10  20 

    a   b   c
0  33   2   3
1  44  10  20 

    a  b   c
0  33  0   3
1  44  0  20 
'''

按行赋值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df, "\n")
df.loc[1] = [33, 44, 55]
print(df, "\n")
df.loc[[0, 1]] = [[33, 44, 55], [66, 77, 88]]
print(df, "\n")

'''
   a   b   c
0  1   2   3
1  5  10  20 

    a   b   c
0   1   2   3
1  33  44  55 

    a   b   c
0  33  44  55
1  66  77  88 
'''

插入操作：

插入一列：

insert(ioc,column,value)

ioc:要插入的位置

colunm:列名

value:值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
print(df, "\n")
df.insert(1,'d',[999,888])
print(df, "\n")

row={'a':111,'d':222,'b':333,'c':444}
df.loc[2]=row
# df.iloc[1]=row 
# df.ix[1]=row 
print(df, "\n")

'''
   a   b   c
0  1   2   3
1  5  10  20 

   a    d   b   c
0  1  999   2   3
1  5  888  10  20 

     a    d    b    c
0    1  999    2    3
1    5  888   10   20
2  111  222  333  444 
'''

添加一行

​ old

df = df.append()

1
2
3
4
5
6
import pandas as pd

data = [{"a": 1, "b": 2, "c": 3}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data)
df=df.append([{'a':3,'b':4,'c':5}],ignore_index=True)
print(df)

注意这里([{的顺序，还有ignore_index=True必须得加，不然index就成了0 1 0

输出结果为：

1
2
3
4
   a   b   c
0  1   2   3
1  5  10  20
2  3   4   5

append()括号中同样可以用另一个dataframe对象，df.append(df2, ignore_index=True)

新版本中已将append方法删除：

DataFrame.append() and Series.append() have been deprecated and will be removed in a future version. Use pandas.concat() instead (GH35407).

pd.concat()

拼接两个Series

1
2
3
4
5
6
7
8
import pandas as pd

s1 = pd.Series(['a', 'b'])
s2 = pd.Series(['c', 'd'])
s = pd.concat([s1, s2])
print(s, '\n')
s = pd.concat([s1, s2], ignore_index=True)
print(s, '\n')

输出为：

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

0    a
1    b
2    c
3    d
dtype: object

拼接两个dataframe

1
2
3
4
5
6
7
import pandas as pd

df1 = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['a', 'b'])

df = pd.concat([df1, df2], ignore_index=True)
print(df)

结果：

1
2
3
4
5
   a  b
0  1  2
1  3  4
2  5  6
3  7  8

如果有多出的列，则缺少的会被NaN填充

1
2
3
4
5
6
7
8
9
10
11
12
>>> df3 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']],
...                    columns=['letter', 'number', 'animal'])
>>> df3
  letter  number animal
0      c       3    cat
1      d       4    dog
>>> pd.concat([df1, df3], sort=False)
  letter  number animal
0      a       1    NaN
1      b       2    NaN
0      c       3    cat
1      d       4    dog

如果只需要共有列，可以选择join=”inner”

如果需要横向拼接，可以设置axis = 1

增加单独一行：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> df7 = pd.DataFrame({'a': 1, 'b': 2}, index=[0])
>>> df7
    a   b
0   1   2
>>> new_row = pd.Series({'a': 3, 'b': 4})
>>> new_row
a    3
b    4
dtype: int64
>>> pd.concat([df7, new_row.to_frame().T], ignore_index=True)
    a   b
0   1   2
1   3   4

当然，也可以直接赋值：

1
2
3
df7 = pd.DataFrame({'a': 1, 'b': 2}, index=[0])
df7.loc[1] = [3, 4]
print(df7)

关于显示输出的问题

import pandas as pd

*#*显示所有列

pd.set_option(‘display.max_columns’, None)

*#*显示所有行

pd.set_option(‘display.max_rows’, None)

None可以写具体的数字，写多少就显示多少,默认是显示100行

import pandas as pd

pd.set_option(‘display.height’, 1000)

pd.set_option(‘display.max_rows’, 500)

pd.set_option(‘display.max_columns’, 500)

pd.set_option(‘display.width’, 1000)

类似的，对于numpy array print后不能完全显示输入下面代码：

numpy.set_printoptions(threshold = np.inf)

#若想不以科学计数显示:

numpy.set_printoptions(suppress = True)