Python - Pandas - 数据分析(1)

前言

Vue框架：从项目学Vue
OJ算法系列：神机百炼 - 算法详解
Linux操作系统：风后奇门 - linux
C++11：通天箓 - C++11

一行检查是否下载过Pandas：
pip list
一行下载：
pip install pandas

两大基本数据结构

一维数组Series

数组初始化：

默认一个数组为一行内数据，且索引为递增的index

import pandas as pd

#数组初始化
series1 = pd.Series([1, 'a', [1.1, 1.2], 'string'])

print(series1)

print(series1[3])

index指定索引：

索引可以不为0 1 2，也可以为其他类型

import numpy as np

series2 = pd.Series([1, 'a', [1.1, 1.2], np.nan], index=['甲', '乙', '丙', '丁'])

print(series2)

print(series2['甲'])

字典同时指定索引&值：

字典一个key对应Series中一行

dictionary = {
    
    '甲':1, '乙':'a', '丙':[123, 456], '丁':np.nan}

series3 = pd.Series(dictionary)

print(series3)

print(series3['丁'])

二维数组DataFrame：

columns初始化：

columns为所有的列属性，独立于数据定义

import pandas as pd
import numpy as np 

#按照行写data
data = [
    ['a', 1, 111],
    ['b', 2, 222],
    ['c', 3, 333]
]
#按照行写columns
columns = ['name', 'class', 'score']

dataframe = pd.DataFrame(data,columns) #dtype=float

print(dataframe)

字典初始化：

字典内一个key对应DataFrame中一列数据
DataFrame中行数据索引仍然是index
列内缺少个数者使用numpy.NaN占位，表示空

import pandas as pd
import numpy as np 

#按照列写字典
dictionary = {
    
    
    'name' : ['a', 'b', 'c'],
    'class': [1, 2, 3],
    'score': [111, 222, 333]
}

dataframe = pd.DataFrame(dictionary) #dtype=float

print(dataframe)

print(dataframe[['name', 'score']])

Series和DataFrame综合：

DataFrame的**一列**可以用Series填充

# data支持多种数据类型

#日期数组
dates = pd.date_range('20130101', periods=4)
#series
series = pd.Series(1, index=list(range(4)), dtype='float32')
#np数组
np_array = np.array([3] * 4, dtype='int32')
#Categorical
categorical = pd.Categorical(["test", "train", "test", "train"])

dataframe1 = pd.DataFrame({
    
    
    'A': 1.,        #可以复用非数组，但不可用数组
    'B': dates,
    'C': series,
    'D': np_array,
    'E': categorical,
    'F': 'foo'
})

print(dataframe1)

基本入门函数：

数据索引：

• 基本数据：

import pandas as pd

dataframe = pd.DataFrame({
    
    
    'a' : [1, 2, 3, 4, 5],
    'b' : ['a', 'b', 'c', 'd', 'e'],
    'c' : [2.1, 2.2, 2.3, 2.4, 2.5]
})
print(dataframe)

切片：

['key1', 'key2', 'key3', ...]

print(dataframe.a)
#等同于：
print(dataframe['a'])
#多列：
print(dataframe[['b', 'c']])

loc：

.loc[a:b, ['key1', 'key2', 'key3', ...]]
行数从a开始，到b，但是不含b

#所有行，c列
print(dataframe.loc[:, ['c']])

#某几行，c列和a列
print(dataframe.loc[0:3, ['c', 'a']])

iloc：

.iloc[a:b:c, d:e:f]
行数从a开始，每次增加c步，不到b
列数从d开始，每次增加f步，不到e

.iloc[a:b:c, [d, e]] 从a行，每次增加c步，不到b
d列和e列

print(dataframe.iloc[0:1, 0:3:2])       

print(dataframe.iloc[0:4, [0, 2]])

• iloc更注重index，而不能直接指定key，毕竟i开头

条件索引：

某个值大小关系：

#打印完整行
print(dataframe[dataframe.a > 3])

#打印行中几个值
print(dataframe.loc[dataframe.a > 2, ['b', 'c']])

某个值是否在其中：

print(dataframe[dataframe['a'].isin([3, 5])])

非原地删除数据：

index[]删行：

#df.index[[1,2,3]]，删索引所指的几行
dataframe2.drop(dataframe2.index[[1, 2]])

[] + axis删列：

dataframe2.drop(['a', 'b'], axis = 1)

删列中某值的行：

dataframe2[~(dataframe2['a'] == 3)]

数据预处理：

• 给定数据如下：

df1 = pd.DataFrame({
    
    'id': [1,2,3],
                   'a': [11,22,33],
                   'b': [111,222,333],})
df2 = pd.DataFrame({
    
    'id': [4,5,6],
                   'd': [1.1,2.2,3.3]})

concat拼接：

join的inner和outer决定缺失时，删除行还是使用NaN填充
axis的0和1决定合并键还是合并index，0合并键，1合并index

axis0 + outer：

#行上外连，合并键，但不合并index，缺失则NAN
pd.concat([df1, df2], axis=0, join='outer')

axis0 + inner：

#行上内连，合并键，但不合并index，缺失则删整行
pd.concat([df1, df2], axis=0, join='inner')

axis1 + outer：

#列上外连，合并index，不合并键，不会出现NaN
pd.concat([df1, df2], axis=1, join='outer')

axis1 + inner：

#列上内连，合并index，不合并键，不会出现NaN
pd.concat([df1, df2], axis=1, join='inner')

merge拼接：

axis=1合并index
merge可以指定key合并，不局限于index

pd.merge(dataframe1, dataframe2, on = 'id')

drop_duplicates()去重：

去重针对的是两个完全一样的行
去重之后，index保持不变，不连续了

• 数据如下：

import pandas as pd

dataframe = pd.DataFrame({
    
    
    'id' : [1, 2, 3, 3, 5],
    'vale' : [1, 2, 3, 3, 5]
})

keep=‘first’：

• 保留重复组中第一个

dataframe.drop_duplicates(keep='first')

keep=‘last’：

• 保留重复组中最后一个

dataframe.drop_duplicates(keep='last')

keep=False：

• 保留重复组中第一个

dataframe.drop_duplicates(keep=False)

删除NaN：

any模式：

一行中含有一个NaN，则这行/列需要丢弃

#含有NaN的行，整个行就丢弃
dataframe3.dropna(how = 'any', axis=0)

#含有NaN的列，整个列就丢弃
dataframe3.dropna(how = 'any', axis=1)

all模式：

一行中都是NaN，这行/列才被丢弃

#指定行中均为NaN，则丢弃整个行
dataframe3.dropna(how = 'all', axis = 0)

#指定列中均为NaN，则丢弃整个列
dataframe3.dropna(how = 'all', axis = 1)

填充NaN：

fillna()：

某值为NaN，则被value填充

dataframe3.fillna(value = 0)

ffill：

按上一行对应值填充：

dataframe3.fillna(method='ffill', axis = 0)

按上一列对应值填充：

dataframe3.fillna(method='ffill', axis = 1)