[Python知识库]StudyNote---Python For Data Analysis

准备工作

1. 安装Anaconda
2. 安装Jupyter notebook
3. 安装ipython

Python语法基础

1. 万物皆对象
2. 动态引用，强类型

isinstance(a, int)  #检查a是否为int实例 

3. 鸭子类型
4. 列表、字典、NumPy数组，和用户定义的类型（类），都是可变的；字符串和元组，是不可变的
5. 对于有换行的字符串，可以使用三引号，’’'或"""
6. 三元表达式

Python数据结构和序列

1. 元组

In [1]: tup = 4, 5, 6

2. tuple方法
3. 列表
4. 二级排序 b.sort(key=len)
5. bisect 二分搜索
6. 匿名函数

equiv_anon = lambda x: x * 2

7. 柯里化：部分参数应用
8. 生成器

NumPy基础

• NumPy是在一个连续的内存块中存储数据，独立于其他Python内置对象。NumPy的C语言编写的算法库可以操作内存，而不必进行类型检查或其它前期工作。比起Python的内置序列，NumPy数组使用的内存更少。
• NumPy可以在整个数组上执行复杂的计算，而不需要Python的for循环。

numpy使用

import numpy as np
# ndarray是一个通用的同构数据多维容器
#也就是说，其中的所有元素必须是相同类型的。每个数组都有一个shape（一个表示各维度大小的元组）
#和一个dtype（一个用于说明数组数据类型的对象
data1 = [6,7.5,8,0,1]
arr1 = np.array(data1)
arr1.shape
arr1.dtype
# 嵌套序列
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)

numpy数组的运算

不用编写循环即可对数据执行批量运算。
NumPy用户称其为矢量化（vectorization）。
大小相等的数组之间的任何算术运算都会将运算应用到元素级

data = [[1.,2.,3.],[4.,5.,6.]]
arr = np.array(data)
arr+arr
arr*arr

基本的索引和切片

数组切片是原始数组的视图。这意味着数据不会被复制，视图上的任何修改都会直接反映到源数组上。

arr = np.arange(10)
#arr:[0,1,2,3,4,5,6,7,8,9]
arr_slice = arr[5:8]
arr_slice[1]=12345
#arr:[0,1,2,3,4,5,12345,7,8,9]

注意：如果想要得到ndarray切片的一份副本而非视图，
就需要明确地进行复制操作，例如arr[5:8].copy()。

切片索引

 arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
 arr2d[:2,1:]
 #第一个表示对行切，第二个表示对列切。
 #切取0，1行。得到[[1,2,3],[4,5,6]]
 #再将得到的数组从1列开始切。得到
 # [[2,3],[5,6]]
 #“只有冒号”表示选取整个轴，因此你可以像下面这样只对高维轴进行切片：
 arr2d[:, :1]
 #array([[1],
   [4],
   [7]])

布尔型索引

In [98]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
In [99]: data = np.random.randn(7, 4)
In [102]: names == 'Bob'
Out[102]: array([ True, False, False,  True, False, False, False], dtype=bool)
In [103]: data[names == 'Bob']

花式索引

以特定顺序选取行子集，
只需传入一个用于指定顺序的整数列表或ndarray

In [117]: arr = np.empty((8, 4))
In [118]: for i in range(8):
   			arr[i] = i
In [120]: arr[[4, 3, 0, 6]]
Out[120]:
array([[ 4.,  4.,  4.,  4.],
       [ 3.,  3.,  3.,  3.],
       [ 0.,  0.,  0.,  0.],
       [ 6.,  6.,  6.,  6.]])

使用负数索引将会从末尾开始选取行
arr[[1, 5, 7, 2], [0, 3, 1, 2]]
选取的是(1,0)、(5,3)、(7,1)和(2,2)
arr[[1, 5, 7, 2]][ :, [0, 3, 1, 2]]
先选取1,5,7,2行。每一行再按照0，3，1，2排序

数组转置和轴对换

#转置
arr.T
#计算矩阵内积
np.dot(arr.T,arr)
#transpose需要得到一个由轴编号组成的元组才能对这些轴进行转置
arr.transpose((1,0,2)) #第一个轴被换成了第二个，第二个轴被换成了第一个，最后一个轴不变。
#swapaxes方法，它需要接受一对轴编号;swapaxes也是返回源数据的视图（不会进行任何复制操作）。

通用函数

对ndarray中的数据执行元素级运算的函数。
可看做简单函数（接受一个或多个标量值，并产生一个或多个标量值）的矢量化包装器。

#返回一个数组
np.sqrt(arr)
np.exp(arr)
np.maximum(x, y)
#返回多个数组
remainder, whole_part = np.modf(arr)
#Ufuncs可以接受一个out可选参数，这样就能在数组原地进行操作
np.sqrt(arr, arr)

其他函数见书

利用数组进行数据处理

用数组表达式代替循环的做法，通常被称为矢量化

np.meshgrid函数接受两个一维数组，并产生两个二维矩阵（对应于两个数组中所有的(x,y)对）
xs, ys = np.meshgrid(points, points)

将条件逻辑表述为数组运算

result = np.where(cond,x,y)
cond为一个条件数组，如果cond中为true,使用x替换，如果为false，使用y替换

数学和统计方法

arr.mean()
arr.mean(axis=1) #计算该轴（1）向上的统计值
arr.sum()
arr.sum(axis=0) #计算该轴（0）向上的统计值
arr.cumsum()
arr.cumsum(axis=0)
arr.cumprod()
arr.cumprod(axis=0)

排序

#就地排序
arr.sort()
arr.sort(0) #按列排序
arr.sort(1) #按行排序
# np.sort()返回数组的已排序副本
np.sort(arr)

唯一化以及其他的集合逻辑

np.unique(names) #找出数组中的唯一值，并返回已排序的结果
np.in1d(values,array) #返回与values等长的布尔型数组，代表每个values数组中的值是否在array中

用于数组的文件输入输出

 np.save('some_array', arr)
 #将多个数组保存到一个未压缩文件中
 np.savez('array_archive.npz', a=arr, b=arr)
 #加载.npz文件
 arch = np.load('array_archive.npz')
 arch['b']
 #需要将数据压缩
 np.savez_compressed('arrays_compressed.npz', a=arr, b=arr)

线性代数

伪随机数生成

samples = np.random.normal(size=(4, 4))
rng = np.random.RandomState(1234) #避免全局状态

示例：随机漫步

pandas入门

Series

相当于一个Map

DataFrame

相当于一个表格

data = {’a':[1,2,3],'b':[4,5,6]}  #a,b相当于列的名称，每列有三个数
frame = np.DataFrame(data) 
frame = np.DataFrame(data，columns['b','a'],index=['one','two','three']) # 列按照b a 从左到右展示 ,行按照one,two,three从上到下展示
# 从DataFrame的列中获取一个Series 。 列可以进行赋值
frame['a']
frame.a
# 获取DataFrame的行
frame.loc['three']
# 对DataFrame进行赋值Series时，会精确匹配DataFrame的索引，空位填上缺失值
frame['a'] = pd.Series([3,4,5],index=['one','three','two'])
# del 可以删除列
del frame['a']
#嵌套字典

索引对象

将索引作为对象，进行存储。
索引对象不可修改，pandas的Index可以包含重复的标签。

index = obj.index
index[1] = 'b'   ?
pd.index = (['a','a','b'])

基本功能

1. 重新索引 reindex

# 返回的是修改后的副本
obj.reindex(['a','c','b'])
obj.reindex(columns = ['ohio','texas','california'])
# 插值，使用ffill可以实现前向值填充
obj.reindex(range(6),method='ffill')
# 修改行和列名称时，已存在的行/列数据不变，原表格未存在的行/列数据为NaN

2. 丢弃指定轴上的项

# 返回的是修改后的副本
obj.drop(['d', 'c'])   # 删除行
data.drop('two', axis=1)   #删除列    axis代表轴，0代表横轴，1代表纵轴
# 就地修改
obj.drop('c', inplace=True)

3. 索引、选取和过滤

# 索引
obj = pd.Series(np.arange(4),index=['a','b','c','d'])
obj['a']
obj[1]
obj[:2]
obj[['a','b']]
obj[obj<2]
obj['a':'c'] #末端包含

4. loc和iloc

loc通过名字，iloc通过整数
data.loc['ohio']
data.loc[['ohio','utah']]    #选行
data.loc[:2,['one','three']]  #选择前两行的one，three列
data.iloc[0]
data.iloc[[0,2]]
data.iloc[:2,[0,2]]

5. 算术运算和数据对齐
   不包括的自动填充NaN

6. DataFrame和Series之间的运算

# 返回副本，广播形式
series = frame.iloc[0]
frame - series  # 将Series的索引匹配到DataFrame的列，然后沿着行一直向下广播
frame + series2 #  某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象就会被重新索引以形成并集
series3 = frame['d']
frame.sub(series3, axis='index') #匹配行，且在列上广播  可axis=0

7. 函数应用和映射

# 常规
np.abs(frame)
# apply
f = lambda x: x.max() - x.min()
frame.apply(f)  # f是一个函数
# apply可以返回由多个值组成的Series
def f(x):
     return pd.Series([x.min(), x.max()], index=['min', 'max'])
frame.apply(f)  # f是一个函数
# applymap 应用于元素级别   （每个数据保留两位小数）
format = lambda x: '%.2f' % x
frame.applymap(format)

8. 排序和排名

# 返回副本
frame.sort_index()
frame.sort_index(axis=1, ascending=False) # 括号中内容选填  此代表按列降序排序
frame.sort_values(by=['b','a'])  # 根据一个或多个列中的值进行排序
frame.rank(axis='columns')  # 在列上计算排名

series.sort_values() # 按值排序  NaN值默认放到series末尾
series.rank() # rank是通过“为各组分配一个平均排名”的方式破坏平级关系
series.rank(method='first') # 根据值在原数据中出现的顺序给出排名：

9. 带有重复标签的轴索引

obj = pd.Series(range(4),index=['a','a','b','c'])
obj['a']   # 返回Series   
obj['b']   # 返回标量
obj.index.is_unique # 返回轴是否重复

汇总和计算描述统计

1. 常规

axis = 0 列
axis = 1 行
df.sum() # 自动排除NaN值   skipna=False 可以取消该功能
df.mean()
df.idxmax()
df.cumsum()
df.describe()  # 一次性产生多个汇总统计
#更多方法查看书

2. 相关系数与协方差

更改axis='columns’ 可以按照行进行计算
returns = price.pct_change() # 计算百分数变换
returns.tail()
returns['MSFT'].corr(returns['IBM']) # corr方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系数
returns['MSFT'].cov(returns['IBM']) # cov用于计算协方差
returns.corrwith(returns.IBM) # 计算其列或行跟另一个Series或DataFrame之间的相关系数
 

3. 唯一值、值计数以及成员资格

uniques = obj.unique() # 得到Series中的唯一值数组：
obj.value_counts() # 计算一个Series中各值出现的频率
pd.value_counts(obj.values, sort=False) # value_counts还是一个顶级pandas方法，可用于任何数组或序列
mask = obj.isin(['b', 'c']) # 判断矢量化集合的成员资格
pd.Index(unique_vals).get_indexer(to_match) # 可以给你一个索引数组，从可能包含重复值的数组到另一个不同值的数组
result = data.apply(pd.value_counts).fillna(0)

数据加载、存储与文件格式

读取文本格式的数据

# 常规
pd.read_csv('examples/ex1.csv')	#自动将第一行作为header, 默认分隔符为逗号
pd.read_csv('examples/ex1.csv',header=None) # 列使用默认0，1，2，3....
pd.read_csv('examples/ex1.csv',names=['a','b','c']) # 指定列名
pd.read_csv('examples/ex1.csv', names=names, index_col='message') #指定message列为索引
parsed = pd.read_csv('examples/ex1.csv',index_col=['key1', 'key2'])# 多个列做成一个层次化索引
pd.read_csv('examples/ex4.csv', skiprows=[0, 2, 3]) #用skiprows跳过文件的第一行、第三行和第四行
pd.isnull(parsed)
sentinels = {'message': ['foo', 'NA'], 'something': ['two']}
pd.read_csv('examples/ex5.csv', na_values=sentinels) # 字典的各列可以使用不同的NA标记值

pd.read_table('ex1.csv') # 默认分隔符为'\t'
pd.read_table('ex1.csv',sep=',') # 指定分隔符','

逐块读取文本文件

pd.read_csv('examples/ex6.csv',nrows = 5) #读取前五行
# 根据chunksize对文件进行逐块迭代
chunker = pd.read_csv('examples/ex6.csv',chunksize=1000) 
tot = pd.Series([])
for piece in chunker:
    tot = tot.add(piece['key'].value_counts(), fill_value=0)
tot = tot.sort_values(ascending=False)

将数据写出到文本格式

data.to_csv('examples/out.csv') # 写入到一个以逗号分割的文件中，(文件中第一个字符为逗号）
data.to_csv('examples/out.csv',sep='|') # 写入到以| 为分隔符的文件中

处理分隔符格式

import csv
f = open('examples/ex7.csv')    # open是打开文件函数，f此时是一个文件对象
reader = csv.reader(f) # reader按行存储
for line in reader:
	print(line) 		# 对reader进行迭代，为每行产生一个元组

剩下的不太懂，记下

JSON 数据

# Json-->对象
result = json.loads(jsonObj)
result['a'] 获取Json属性为a 的那个
siblings = pd.DataFrame(result['siblings'], columns=['name', 'age']) # 传入result['xx'] 
# 特别格式的JSON数据集 会自动转换
data = pd.read_json('examples/example.json')
# 对象-->Json
jsonObj = json.dumps(result)

XML和HTML

主要下载lxml和beautifulsoup4和html5lib

conda install lxml
pip install beautifulsoup4 html5lib

利用lxml.objectify解析XML

用lxml.objectify解析文件，然后通过getroot得到该XML文件的根节点的引用
不是很懂，记下此处。

path = 'datasets/mta_perf/Performance_MNR.xml'
parsed = objectify.parse(open(path))
root = parsed.getroot()

二进制数据格式

frame.to_pickle('examples/frame_pickle') # 以pickle格式保存到磁盘上
pd.read_pickle('examples/frame_pickle') # 读取被pickle化的数据
# pickle仅建议用于短期存储格式

HDF5格式

# 存储到mydata.h5
store = pd.HDFStore('mydata.h5')
store['obj1'] = frame
store['obj1_col'] = frame['a']
store
# HDF5对象的获取
store['obj1']
# 查询
store.put('obj2', frame, format='table')
store.select('obj2', where=['index >= 10 and index <= 15'])

读取Microsoft Excel文件

# 创建路径
xlsx = pd.ExcelFile('examples/ex1.xlsx')
# 读取excel文件
pd.read_excel(xlsx, 'Sheet1')
frame = pd.read_excel('examples/ex1.xlsx', 'Sheet1') # 等价

# 写成excel格式
# 创建ExcelWriter
writer = pd.ExcelWriter('examples/ex2.xlsx')
# to_excel方法
frame.to_excel(writer, 'Sheet1')
writer.save()
# 以下等价
frame.to_excel('examples/ex2.xlsx')

Web APIs交互

resp = requests.get(url)
# 响应对象的json方法会返回一个包含被解析过的JSON字典
data = resp.json()
data[0]['title']   # 显示data 0行 title 列 对应的数据
# 提取感兴趣的字段
issues = pd.DataFrame(data, columns=['number', 'title','labels', 'state'])

数据库交互

con = sqlite3.connect('mydata.sqlite')
con.execute(query)
# 插入数据
data = [('Atlanta', 'Georgia', 1.25, 6),('Tallahassee', 'Florida', 2.6, 3),('Sacramento', 'California', 1.7, 5)]
stmt = "INSERT INTO test VALUES(?, ?, ?, ?)"
con.executemany(stmt,data)
# 返回元组列表
cursor = con.execute('select * from test')
rows = cursor.fetchall()
pd.DataFrame(rows, columns=[x[0] for x in cursor.description])
# sqlalchemy
db = sqla.create_engine('sqlite:///mydata.sqlite')
pd.read_sql('select * from test', db)