In [ ]:
import pandas as pd
import numpy as np
# DataFrame对象
data = {
'color':['blue','green','yellow','red','white'],
'object':['ball', 'pen', 'pencil', 'paper', 'mug'],
'price':[1.2, 1.0, 0.6, 0.9, 1.7]}
frame = pd.DataFrame(data)
print(frame)
print("=============================================")
# 新增序列
ser = pd.Series(np.arange(5))
frame['new'] = ser
print(frame)
print("=============================================")
# 元素的所属关系
print(frame.isin([1.0, 'pen']))
print(frame[frame.isin([1.0, 'pen'])])
print("=============================================")
# 删除一列
del frame['new']
print(frame)
print("=============================================")
# 筛选
print(frame[frame < 1.2])
print("=============================================")
# 用嵌套字典生成DataFrame对象
dict_nest = {
'red': {2012:22, 2018:33},
'white': {2011:13, 2012:22, 2013:16},
'blue': {2011:17, 2012:27, 2013:18}
}
frame2 = pd.DataFrame(dict_nest)
print(frame2)
print("=============================================")
# DataFrame转置(列变为行，行变为列)
frame2.T
In [ ]:
ser = pd.Series([5,0,3,8,4], index=['red','blue','yellow','white','green'])
ser.index
# Index对象的方法, 返回索引值最小和最大的元素
ser.idxmin()
ser.idxmax()
# 含有重复标签的Index(同样适用于存在重复项的DataFrame, 其返回结果为DataFrame对象)
serd = pd.Series(range(6), index=['white', 'white', 'red','blue','yellow','green'])
serd
serd['white']
serd.index.is_unique # False
frame.index.is_unique # True
In [ ]:
# 更换索引
ser = pd.Series([2,5,7,4], index=['one', 'two', 'three', 'four'])
ser
# 更换索引
ser.reindex(['three', 'four', 'five', 'one'])
# 自动填充或插值方法
ser3 = pd.Series([1,5,6,3], index=[0,3,5,6])
ser3
# 使用reindex()函数，method选项的值为ffill，还需要指定索引值的范围
# 新插入的索引项目，为前面索引编号比它小的那个一项的元素
ser3.reindex(range(6), method='ffill')
# DataFrame对象
data = {
'color':['blue','green','yellow','red','white'],
'object':['ball', 'pen', 'pencil', 'paper', 'mug'],
'price':[1.2, 1.0, 0.6, 0.9, 1.7]}
frame = pd.DataFrame(data)
frame.reindex(range(5), method='ffill', columns=['colors', 'price', 'new', 'object'])
# 删除
ser = pd.Series(np.arange(4), index=['red', 'blue', 'yellow', 'white'])
ser
ser.drop('yellow') # 删除标签为yellow这一项
ser.drop(['blue', 'white'])
# 删除DataFrame中的元素,需要指定元素两个轴的轴标签
frame
# frame.drop([0, 1]) # 删除行
frame.drop(['color', 'object'], axis=1) # 删除列
In [ ]:
# 算术和数据对齐
s1 = pd.Series([3,2,5,1], ['white', 'yellow', 'green', 'blue'])
s2 = pd.Series([1,4,7,2,1], ['white', 'yellow','black', 'blue', 'brown'])
s1+s2
# 同理对DataFrame对象
frame1 = pd.DataFrame(np.arange(16).reshape((4,4)),
index=['red', 'blue', 'yellow', 'white'],
columns=['ball', 'pen', 'pencil', 'paper'])
frame2 = pd.DataFrame(np.arange(12).reshape((4,3)),
index=['blue', 'green', 'white', 'yellow'],
columns=['mug', 'pen', 'ball'])
frame1+frame2
In [ ]:
# 数据结构之间的运算
# add(), sub(), div(), mul()
frame1.add(frame2)
In [ ]:
# DataFrame和Series对象之间的运算
frame = pd.DataFrame(np.arange(16).reshape((4,4)),
index=['red', 'blue', 'yellow', 'white'],
columns=['ball', 'pen', 'pencil', 'paper'])
print(frame)
print("==================================================")
ser = pd.Series(np.arange(4), index=['ball', 'pen', 'pencil', 'paper'])
print(ser)
frame-ser # 为每一行减去ser
# 如果一个索引项只存在于其中一个数据结构之中
# 则运算结果中会为该索引项生成一列
# 只不过该列的所有元素都是NaN
ser['mug'] = 9
ser
frame-ser
In [ ]:
# pandas库以NumPy为基础，并对很多功能进行扩展
# 新数据结构Series和DataFrame
# 通用函数ufunc，就是经过扩展得到的
frame = pd.DataFrame(np.arange(16).reshape((4,4)),
index=['red', 'blue', 'yellow', 'white'],
columns=['ball', 'pen', 'pencil', 'paper'])
print(frame)
print("==================================================")
ret = np.sqrt(frame) # 对每个元素的平方根
print(ret)
# 按行或列执行操作的函数
# 第一种形式
f = lambda x: x.max() - x.min()
#第二种形式
def f(x):
return x.max() - x.min()
ret = frame.apply(f) # 使用apply函数可以在DataFrame对象上调用刚定义的函数
print(ret)
# 处理行
print(frame.apply(f, axis=1))
# apply()函数并不一定返回标量，还可以返回Series对象
# 可以借助它同时执行多个函数，返回两个或两个以上的结果
def f(x):
return pd.Series([x.min(), x.max()], index=['min', 'max'])
frame.apply(f)
# 统计函数
# 数组的大多数统计函数对DataFrame对象依旧有效，因此没有必要使用apply()函数
# 比如， sum(),mean()
frame.sum()
frame.mean()
frame.describe()
In [ ]:
# 排序和排位次
ser = pd.Series([5,0,3,8,4], index=['red', 'blue', 'yellow', 'white', 'green'])
ser.sort_index() # 字母升序
ser.sort_index(ascending=False) # 字母降序
# 对于DataFrame对象，可以分别对两条轴中的任意一条进行排序
# 对行进行排序，依旧使用sort_index()函数
# 对于列需要执行axis选项，其值为1
frame = pd.DataFrame(np.arange(16).reshape((4,4)),
index=['red', 'blue', 'yellow', 'white'],
columns=['ball', 'pen', 'pencil', 'paper'])
print(frame)
print("==================================================")
print(frame.sort_index()) # 对行进行排序
print("==================================================")
print(frame.sort_index(axis=1)) # 对列进行排序
# 对数据结构中的原序进行排序
# 对于Serires对象，使用order()函数
# print(ser.order())
# frame.sort_values(by='pen')
frame.sort_values(by=['pen', 'pencil'])
# 排位次操作（ranking）
ser.rank()
ser.rank(method='first')
In [ ]:
# 相关性和协方差
# 相关性(correlation)和协方差(covariance)
# 分别使用函数corr()和cov()
seq2 = pd.Series([3,4,3,4,5,4,3,2], ['2006','2007','2008','2009','2010','2011','2012','2013'])
seq = pd.Series([1,2,3,4,4,3,2,1], ['2006','2007','2008','2009','2010','2011','2012','2013'])
seq.corr(seq2)
seq.cov(seq2)
# 计算单个DataFrame对象的相关性和协方差，返回两个新DataFrame对象形式的举证
frame2 = pd.DataFrame([[1,4,3,6],[4,5,6,1],[3,3,1,5],[4,1,6,4]],
index=['red', 'blue', 'yellow', 'white'],
columns=['ball', 'pen', 'pencil', 'paper'])
frame2.corr()
frame2.cov()
# 使用corrwith()方法计算DataFrame对象的列或行
# 与Series对象或其他DataFrame对象元素两两之间的相关性
ser
frame2.corrwith(ser)
frame2.corrwith(frame)
In [ ]:
# NaN数据
# 为元素赋NaN值
ser = pd.Series([0,1,2,np.NaN, 9], index=['red', 'blue', 'yellow', 'white', 'green'])
ser
ser['red'] = None
ser
# 过滤NaN
# 方法一
ser.dropna()
print(ser.dropna())
# 方法二
ser[ser.notnull()]
# 对于DataFrame处理，使用dropna()方法，只要一行或列有一个NaN元素
# 该行或列的全部元素都会被删除
frame3 = pd.DataFrame([[6, np.NaN, 6],[np.nan, np.nan, np.nan],[2,np.nan, 5]],
index = ['blue', 'green', 'red'],
columns = ['ball', 'mug', 'pen'])
print(frame3)
frame3.dropna() # 不对
# 为了避免删除整行或整列，需要使用how选项，指定其值为all，
# 告诉dropna()函数只删除所有元素均为NaN的行或列
frame3.dropna(how='all')
frame3.dropna(how='all', axis=1)
# 为NaN元素填充其他值
frame3.fillna(0)
frame3.fillna({'ball':1, 'mug': 0, 'pen': 99}) # 指定列名称以及要替换成的元素
# 等级索引和分级
mser = pd.Series(np.random.rand(8),
index=[['white', 'white', 'white', 'blue', 'blue', 'red', 'red', 'red'],
['up','down','right','up','down','up','down','left']])
print(mser)
print(mser['white'])
print(mser[:,'up'])
print(mser['white', 'up']) # 选取某一特定的元素，指定两个索引即可
mser.unstack() # 转换为一个简单的DataFrame对象，其中把第二列索引转换为相应的列
type(frame)
frame
frame.stack() # 转换为Series对象
# 对于DataFrame对象，可以为它的行和列都定义等级索引
mframe = pd.DataFrame(np.random.randn(16).reshape(4,4),
index=[['white','white','red','red'],['up','down','up','down']],
columns=[['pen','pen','paper','paper'],[1,2,1,2]])
mframe
In [ ]:
# 重新调整顺序和为层级排序
# 调整某一条轴上各层级的顺序或调整某一层中各元素的顺序
mframe.columns.names = ['object', 'id']
mframe.index.names = ['colors','status']
mframe
mframe.swaplevel('colors','status') # 交换位置
import sys
mframe.sort_index(level='colors', ascending=True) # 排序
In [ ]:
# 按层级统计数据
# DataFrame或Series对象的很多描述性和概括统计量都有level选项
# 可以指定获取哪个层级的描述心和概括统计量
mframe.sum(level='colors')
mframe.sum(level='id', axis=1) # 对某一个层级的列进行统计，比如id，需要把axis选项设置为1
In [ ]:
import pandas as pd
# 读取csv文件
# 没有表头，使用header选项，将其值置为None,pandas会为其添加默认表头
data = pd.read_csv('数据分析/res/worldcup_team_csv.csv', header=None)
# 可以指定表头
data = pd.read_csv('数据分析/res/worldcup_team_csv.csv', names=['white','red','blue','green','animal'])
In [ ]:
print(len(data.columns))
for col in data.columns:
print(col)
# series = data[col]
# print(series)
In [ ]:
t = pd.to_datetime('2010/11/12', format='%Y/%m/%d')
print(t)
from datetime import datetime
dates = [datetime(2012, 5, 1), datetime(2012, 5, 2), datetime(2012, 5, 3)]
In [ ]:
s = pd.Series(np.arange(100),index=pd.timedelta_range('1 days', periods=100, freq='h'))
In [ ]:
import pandas as pd
import numpy as np
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
%matplotlib inline
data = {'birth': ['10/8/00', '7/21/93', '6/14/01', '5/18/99', '1/5/98']}
frame = DataFrame(data)
frame['birth'] = pd.to_datetime(frame['birth'])
frame
import datetime as dt
now_year =dt.datetime.today().year #当前的年份
frame['age']=now_year-frame.birth.dt.year
frame
In [ ]:
# 读写HTML文件
# read_html(), to_html()
# html5lib模块: pip install html5lib
frame = pd.DataFrame(np.arange(4).reshape(2,2))
print(frame.to_html())
In [ ]:
frame = pd.DataFrame(np.random.random((4,4)),
index=['white','black', 'red','blue'],
columns=['up','down','right','left'])
s = ['<HTML>']
s.append('<HEAD><TITLE>My DataFrame</TITLE></HEAD>')
s.append('<body>')
s.append(frame.to_html())
s.append('</body></html>')
html = ''.join(s)
# 写入html文件
html_file = open('myframe.html', 'w')
html_file.write(html)
html_file.close()
# 读取html文件
web_frames = pd.read_html('myframe.html')
web_frames[0]
In [ ]:
# 从xml读取数据
# 引入库
from lxml import objectify
xml = objectify.parse('some.xml')
In [ ]:
# 读取Excel文件
# to_excel(), read_excel()
data1 = pd.read_excel('数据分析/res/data.xls', 'Sheet 1')
data2 = pd.read_excel('数据分析/res/data.xls', 'Sheet 2')
# 将DataFrame转换为Excel
frame = pd.DataFrame(np.random.random((4,4)),
index=['exp1', 'exp2', 'exp3', 'exp4'],
columns=['Jan2015', 'Fab2015','Mar2015','Apr2015'])
frame.to_excel('数据分析/res/data2.xls')
In [ ]:
# JSON数据
# read_json(), to_json()
frame = pd.DataFrame(np.random.random((4,4)),
index=['white','black', 'red','blue'],
columns=['up','down','right','left'])
print(frame)
frame.to_json('数据分析/res/frame.json')
pd.read_json('数据分析/res/frame.json')
# 有时候需要规范化(normalization)
# 使用pandas库的json_normalize()函数，将字典或列表转换为表格
from pandas.io.json import json_normalize
file = open('数据分析/res/books.json', 'r')
text = file.read()
print(text)
text = json.loads(text)
json_normalize(text, 'books') # 把books作为键的元素的值，该函数使用一串递增的数字作为索引
json_normalize(text, 'books', ['writer', 'nationality']) # 增加books同一级的其他键值
In [ ]:
# HDF5格式, 二进制格式
# HDF代表等级数据格式(hierarchical data format), 由c语言开发
# HDF5格式数据的方法：PyTables和h5py
# h5py为HDF5的高级API提供接口，PyTables封装了很多HDF5细节
# HDFStroe, 类似dict类，用PyTables存储pandas对象
from pandas.io.pytables import HDFStore
frame = pd.DataFrame(np.random.random((4,4)),
index=['white','black', 'red','blue'],
columns=['up','down','right','left'])
store = pd.HDFStore('数据分析/res/mydata2.h5')
store['obj1'] = frame
store['obj2'] = frame
print(store)
In [ ]:
# pickle python对象序列化
import pickle as pk
data = {'color':['white', 'red'], 'value':[5,7]}
pickled_data = pk.dumps(data)
print(pk.loads(pickled_data))
In [ ]:
# 用pandas实现对象序列化
frame = pd.DataFrame(np.arange(16).reshape(4,4), index=['up','down','left','right'])
frame.to_pickle('数据分析/res/frame.pkl')
ret = pd.read_pickle('数据分析/res/frame.pkl')
ret
In [ ]:
# 内置SQLite3数据读写
from sqlalchemy import create_engine
frame = pd.DataFrame(np.arange(20).reshape(4,5),
columns=['white','red','blue','black','green'])
engine = create_engine('sqlite:///数据分析/res/foo.db')
# frame.to_sql('colors', engine) # 保存数据库
pd.read_sql('colors', engine) # 读取数据库
In [107]:
import sqlite3
query = """CREATE TABLE test (a VARCHAR(20), b VARCHAR(20), c REAL, d INTEGER);"""
con = sqlite3.connect(':memory:')
con.execute(query)
Out[107]:
In [108]:
con.commit()
In [109]:
data = [('white', 'up', 1, 3),
('black', 'down', 2, 8),
('green', 'up', 4, 4),
('red','down', 5,5)]
stmt = "INSERT INTO test VALUES(?,?,?,?)"
con.executemany(stmt, data)
Out[109]:
In [110]:
con.commit()
In [129]:
cursor = con.execute('select * from test')
cursor
rows = cursor.fetchall()
rows
# 可以把元组列表传给DataFrame的构造函数，如需要列名称，
# 可以用游标的description属性来获取
cursor.description
"""
因为 python 3.x 需要 list()后，再索引查找元素
改为 DataFrame(rows, columns=list(zip(*cursor.description))[0])
"""
pd.DataFrame(rows, columns=list(zip(*cursor.description))[0])
Out[129]:
In [132]:
# 使用pgAdmin
import psycopg2
engine = create_engine('postgresql://postgres:password@localhost:54749/postgres')
frame = pd.DataFrame(np.random.random((4,4)),
index=['exp1','exp2','exp3','exp4'],
columns=['fed','mar','apr','may'])
frame.to_sql('dataframe', engine)
In [121]:
Out[121]:
In [ ]: