python：pandas模块最全最详细的教程

pandas模块介绍

pandas官方文档：https://pandas.pydata.org/pandas-docs/stable/?v=20190307135750

pandas基于Numpy，可以看成是处理文本或者表格数据。pandas中有两个主要的数据结构，其中Series数据结构类似于Numpy中的一维数组，DataFrame类似于多维表格数据结构。

pandas是python数据分析的核心模块。它主要提供了五大功能:

• 支持文件存取操作，支持数据库(sql)、html、json、pickle、csv(txt、excel)、sas、stata、hdf等。
• 支持增删改查、切片、高阶函数、分组聚合等单表操作，以及和dict、list的互相转换。
• 支持多表拼接合并操作。
• 支持简单的绘图操作。
• 支持简单的统计分析操作。

一、Series数据结构

Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签（索引）组成。

Series比较像列表（数组）和字典的结合体

import numpy as np
import pandas as pd

df = pd.Series(0, index=['a', 'b', 'c', 'd'])
print(df)

a    0
b    0
c    0
d    0
dtype: int64
    
print(df.values)
# [0 0 0 0]

print(df.index)
# Index(['a', 'b', 'c', 'd'], dtype='object')

1 Series支持NumPy模块的特性（下标）

arr = np.array([1, 2, 3, 4, np.nan])
print(arr)
# [ 1.  2.  3.  4. nan]


df = pd.Series(arr, index=['a', 'b', 'c', 'd', 'e'])
print(df)
# 结果：
    a    1.0
    b    2.0
    c    3.0
    d    4.0
    e    NaN
	dtype: float64
    
    
print(df**2)
# 结果：
    a     1.0
    b     4.0
    c     9.0
    d    16.0
    e     NaN
    dtype: float64
        
print(df[0])
# 1.0

print(df['a'])
# 1.0

print(df[[0, 1, 2]])
# 结果：
    a    1.0
    b    2.0
    c    3.0
    dtype: float64
        
print(df[0:2])
# 结果：
    a    1.0
    b    2.0
    dtype: float64
        
np.sin(df)
# 结果：
    a    0.841471
    b    0.909297
    c    0.141120
    d   -0.756802
    e         NaN
    dtype: float64
        
df[df > 1]
# 结果：
    b    2.0
    c    3.0
    d    4.0
    dtype: float64

2 Series支持字典的特性（标签）

df = pd.Series({'a': 1, 'b': 2})
print(df)
# 结果：
    a    1
    b    2
    dtype: int64
        
print('a' in df)
# True

print(df['a'])
# 1

3 Series缺失数据处理

df = pd.Series([1, 2, 3, 4, np.nan], index=['a', 'b', 'c', 'd', 'e'])
print(df)
# 结果：
    a    1.0
    b    2.0
    c    3.0
    d    4.0
    e    NaN
    dtype: float64
        
print(df.dropna())
# 结果：
    a    1.0
    b    2.0
    c    3.0
    d    4.0
    dtype: float64

print(df.fillna(5))
# 结果：	
    a    1.0
    b    2.0
    c    3.0
    d    4.0
    e    5.0
    dtype: float64

print(df.isnull())
# 结果
    a    False
    b    False
    c    False
    d    False
    e     True
    dtype: bool
    
print(df.notnull())
# 结果：
    a     True
    b     True
    c     True
    d     True
    e    False
    dtype: bool

二、DataFrame数据结构

DataFrame是一个表格型的数据结构，含有一组有序的列。

DataFrame可以被看做是由Series组成的字典，并且共用一个索引。

1 产生时间对象数组：date_range

date_range参数详解：

dates = pd.date_range('20190101', periods=6, freq='M')
print(dates)
# 结果：
DatetimeIndex(['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',
               '2019-05-31', '2019-06-30'],
              dtype='datetime64[ns]', freq='M')


np.random.seed(1)
arr = 10 * np.random.randn(6, 4)
print(arr)
# 结果：
[[ 16.24345364  -6.11756414  -5.28171752 -10.72968622]
 [  8.65407629 -23.01538697  17.44811764  -7.61206901]
 [  3.19039096  -2.49370375  14.62107937 -20.60140709]
 [ -3.22417204  -3.84054355  11.33769442 -10.99891267]
 [ -1.72428208  -8.77858418   0.42213747   5.82815214]
 [-11.00619177  11.4472371    9.01590721   5.02494339]]


df = pd.DataFrame(arr, index=dates, columns=['c1', 'c2', 'c3', 'c4'])
df

三、DataFrame属性

# 查看数据类型
print(df2.dtypes)
# 结果：
    0    float64
    1    float64
    2    float64
    3    float64
    dtype: object
        
       
df

print(df.index)
# 结果：
DatetimeIndex(['2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',
               '2019-05-31', '2019-06-30'],
              dtype='datetime64[ns]', freq='M')

print(df.columns)
# 结果：
Index(['c1', 'c2', 'c3', 'c4'], dtype='object')


print(df.values)
# 结果：
[[ 16.24345364  -6.11756414  -5.28171752 -10.72968622]
 [  8.65407629 -23.01538697  17.44811764  -7.61206901]
 [  3.19039096  -2.49370375  14.62107937 -20.60140709]
 [ -3.22417204  -3.84054355  11.33769442 -10.99891267]
 [ -1.72428208  -8.77858418   0.42213747   5.82815214]
 [-11.00619177  11.4472371    9.01590721   5.02494339]]


df.describe()

df.T

# 按行标签[c1, c2, c3, c4]从大到小排序
df.sort_index(axis=0)

# 按列标签[2019-01-01, 2019-01-02...]从大到小排序
df.sort_index(axis=1)

# 按c2列的值从大到小排序
df.sort_values(by='c2')

四、DataFrame取值

df

1 通过columns取值

df['c2']
# 结果：
    2019-01-31    -6.117564
    2019-02-28   -23.015387
    2019-03-31    -2.493704
    2019-04-30    -3.840544
    2019-05-31    -8.778584
    2019-06-30    11.447237
    Freq: M, Name: c2, dtype: float64
                
df[['c2', 'c3']]

2 loc（通过行标签取值）

# 通过自定义的行标签选择数据
df.loc['2019-01-01':'2019-01-03']

df[0:3]

3 iloc（类似于numpy数组取值）

df.values
# 结果：
    array([[ 16.24345364,  -6.11756414,  -5.28171752, -10.72968622],
           [  8.65407629, -23.01538697,  17.44811764,  -7.61206901],
           [  3.19039096,  -2.49370375,  14.62107937, -20.60140709],
           [ -3.22417204,  -3.84054355,  11.33769442, -10.99891267],
           [ -1.72428208,  -8.77858418,   0.42213747,   5.82815214],
           [-11.00619177,  11.4472371 ,   9.01590721,   5.02494339]])

# 通过行索引选择数据
print(df.iloc[2, 1])
# -2.493703754774101


df.iloc[1:4, 1:4]

4 使用逻辑判断取值

df[df['c1'] > 0]

df[(df['c1'] > 0) & (df['c2'] > -8)]

五、DataFrame值替换

df

df.iloc[0:3, 0:2] = 0
df

df['c3'] > 10
# 结果：
    2019-01-31    False
    2019-02-28     True
    2019-03-31     True
    2019-04-30     True
    2019-05-31    False
    2019-06-30    False
    Freq: M, Name: c3, dtype: bool
                
# 针对行做处理
df[df['c3'] > 10] = 100
df

# 针对行做处理
df = df.astype(np.int32)
df[df['c3'].isin([100])] = 1000
df

六、读取CSV文件

import pandas as pd
from io import StringIO
test_data = '''
5.1,,1.4,0.2
4.9,3.0,1.4,0.2
4.7,3.2,,0.2
7.0,3.2,4.7,1.4
6.4,3.2,4.5,1.5
6.9,3.1,4.9,
,,,
'''

test_data = StringIO(test_data)
df = pd.read_csv(test_data, header=None)
df.columns = ['c1', 'c2', 'c3', 'c4']
df

七、处理丢失数据

df.isnull()

# 通过在isnull()方法后使用sum()方法即可获得该数据集某个特征含有多少个缺失值
print(df.isnull().sum())
# 结果：
    c1    1
    c2    2
    c3    2
    c4    2
    dtype: int64
# Python学习交流群：711312441        
# axis=0删除有NaN值的行
df.dropna(axis=0)

# axis=1删除有NaN值的列
df.dropna(axis=1)

# 删除全为NaN值得行或列
df.dropna(how='all')

# 删除行不为4个值的
df.dropna(thresh=4)

# 删除c2中有NaN值的行
df.dropna(subset=['c2'])

# 填充nan值
df.fillna(value=10)

八、合并数据

df1 = pd.DataFrame(np.zeros((3, 4)))
df1

df2 = pd.DataFrame(np.ones((3, 4)))
df2

# axis=0合并列
pd.concat((df1, df2), axis=0)

# axis=1合并行
pd.concat((df1, df2), axis=1)

	0 	1 	2 	3 	0 	1 	2 	3
0 	0.0 	0.0 	0.0 	0.0 	1.0 	1.0 	1.0 	1.0
1 	0.0 	0.0 	0.0 	0.0 	1.0 	1.0 	1.0 	1.0
2 	0.0 	0.0 	0.0 	0.0 	1.0 	1.0 	1.0 	1.0

# append只能合并列
df1.append(df2)

九、导入导出数据

使用df = pd.read_excel(filename)读取文件，使用df.to_excel(filename)保存文件。

1 读取文件导入数据

读取文件导入数据函数主要参数：

df = pd.read_excel(filename)
df = pd.read_csv(filename)

2 写入文件导出数据

写入文件函数的主要参数：

df.to_excel(filename)

十、pandas读取json文件

strtext = '[{"ttery":"min","issue":"20130801-3391","code":"8,4,5,2,9","code1":"297734529","code2":null,"time":1013395466000},\
{"ttery":"min","issue":"20130801-3390","code":"7,8,2,1,2","code1":"298058212","code2":null,"time":1013395406000},\
{"ttery":"min","issue":"20130801-3389","code":"5,9,1,2,9","code1":"298329129","code2":null,"time":1013395346000},\
{"ttery":"min","issue":"20130801-3388","code":"3,8,7,3,3","code1":"298588733","code2":null,"time":1013395286000},\
{"ttery":"min","issue":"20130801-3387","code":"0,8,5,2,7","code1":"298818527","code2":null,"time":1013395226000}]'
#Python学习交流群：711312441
df = pd.read_json(strtext, orient='records')
df

df.to_excel('pandas处理json.xlsx',
            index=False,
            columns=["ttery", "issue", "code", "code1", "code2", "time"])

1 orient参数的五种形式

orient是表明预期的json字符串格式。orient的设置有以下五个值：

‘split’ : dict like {index -> [index], columns -> [columns], data -> [values]}

这种就是有索引，有列字段,和数据矩阵构成的json格式。key名称只能是index,columns和data。

s = '{"index":[1,2,3],"columns":["a","b"],"data":[[1,3],[2,8],[3,9]]}'
df = pd.read_json(s, orient='split')
df

‘records’ : list like [{column -> value}, … , {column -> value}]

这种就是成员为字典的列表。如我今天要处理的json数据示例所见。构成是列字段为键,值为键值,每一个字典成员就构成了dataframe的一行数据。

strtext = '[{"ttery":"min","issue":"20130801-3391","code":"8,4,5,2,9","code1":"297734529","code2":null,"time":1013395466000},\
{"ttery":"min","issue":"20130801-3390","code":"7,8,2,1,2","code1":"298058212","code2":null,"time":1013395406000}]'

df = pd.read_json(strtext, orient='records')
df

‘index’ : dict like {index -> {column -> value}}

以索引为key,以列字段构成的字典为键值。如：

s = '{"0":{"a":1,"b":2},"1":{"a":9,"b":11}}'
df = pd.read_json(s, orient='index')
df

‘columns’ : dict like {column -> {index -> value}}

这种处理的就是以列为键，对应一个值字典的对象。这个字典对象以索引为键,以值为键值构成的json字符串。如下图所示:

s = '{"a":{"0":1,"1":9},"b":{"0":2,"1":11}}'
df = pd.read_json(s, orient='columns')
df

‘values’ : just the values array。

values这种我们就很常见了。就是一个嵌套的列表。里面的成员也是列表，2层的。

s = '[["a",1],["b",2]]'
df = pd.read_json(s, orient='values')
df

十一、pandas读取sql语句

import numpy as np
import pandas as pd
import pymysql


def conn(sql):
    # 连接到mysql数据库
    conn = pymysql.connect(
        host="localhost",
        port=3306,
        user="root",
        passwd="123",
        db="db1",
    )
    try:
        data = pd.read_sql(sql, con=conn)
        return data
    except Exception as e:
        print("SQL is not correct!")
    finally:
        conn.close()


sql = "select * from test1 limit 0, 10"  # sql语句
data = conn(sql)
print(data.columns.tolist())  # 查看字段
print(data)  # 查看数据