【python学习笔记之numpy与pandas】

---

numpy和pandas的关系

pandas是基于numpy构建的，让numpy为中心的应用更加简单

numpy篇

每一个np数组都有一个shape属性【获取数组维度】和dtype属性【获取数组类型】；
numpy可以在不编写循环的情况下进行矢量化运算

嵌套序列

嵌套序列,由一组等长列表组成
arr.ndim:外层数组的维度
arr.shape:（外层数组的维度，内层数组的维度）

#二维数组(嵌套序列)的访问
arr1 = np.array([[1,2,3],[4,5,6]])
print(arr1[0][1])
print(arr1[0,1])
#2
#2
arr1.ndim
#2
arr1.shape
#(2,3)

花式索引：

以一个特定的顺序选取行；利用整数数组进行索引

#对二维数组的访问
arr = np.empty((8,4))
for i in range(8):
    arr[i]=i
print(arr)
print(arr[[4,3,0,6]])#x选取的是特定的行

‘’‘
#print（arr）
 [[0. 0. 0. 0.]
 [1. 1. 1. 1.]
 [2. 2. 2. 2.]
 [3. 3. 3. 3.]
 [4. 4. 4. 4.]
 [5. 5. 5. 5.]
 [6. 6. 6. 6.]
 [7. 7. 7. 7.]]
#print（[4,3,0,6]）
[[4. 4. 4. 4.]
 [3. 3. 3. 3.]
 [0. 0. 0. 0.]
 [6. 6. 6. 6.]]
 ’‘’

reshape函数；
各种切片；
ix_()

arr2=np.arange(32).reshape(8,4)#将0-31进行排序，形成8行*4列的二维数组
print(arr2)
print(arr2[[1,5,7,2],[0,3,1,2]])#选出下标为（1，0）（5，3）（7，1）（2，2）的元素
#第一个[]选择的是行，第二个[]选的是列
'''
[[ 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 25 26 27]
 [28 29 30 31]]
 
[ 4 23 29 10]
'''
print(arr2[[1,5,7,2]])#第1，5，7，2行被筛出
print(arr2[[1,5,7,2]][:,[0,3,1,2]]) #第1，5，7，2行的，'：'表示所有列元素，0，3，1，2是行的顺序
#上面👆也可以写成  arr2[np.ix_([1,5,7,2],[0,3,1,2])]
'''
#print(arr2[[1,5,7,2]])
[[ 4  5  6  7]
 [20 21 22 23]
 [28 29 30 31]
 [ 8  9 10 11]]
#print(arr2[[1,5,7,2]][:,[0,3,1,2]])
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]
 '''

数组转置

数组转置：arr.transpose()

#三维数组的转置
arr = np.arange(24).reshape((2,3,4))
print(arr)#默认为（0，1，2）
print(arr.transpose(1,2,0))
'''
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
  #转置后
[[[ 0 12]
  [ 1 13]
  [ 2 14]
  [ 3 15]]

 [[ 4 16]
  [ 5 17]
  [ 6 18]
  [ 7 19]]

 [[ 8 20]
  [ 9 21]
  [10 22]
  [11 23]]]
  '''

---

python的高阶函数

• lambda函数【匿名函数】
  （适合一些简单表达式）

格式：lambda 参数列表 ：函数体

• 三元运算符

格式：（成立的结果 if condition 不成立结果）= np.where(condition,成功结果,失败结果)

• map函数
  将interable中的书都实现func函数

格式：map（func,*iterable）

• filter过滤器

格式：filter（func，iterable）

• reduce函数
  下次运算用上次的结果

格式：（func，interable，初始值）
需要导包：from functools import reduce

• zip函数

用于将迭代对象作为参数，将对象中对应元素打包成一个元组，并返回元组

矩阵的运算

dot:格式x.dot(y)；矩阵乘法
trace:矩阵对角线之和
det:矩阵行形式
eig:计算特征值和特征向量
inv:求矩阵的逆

---

python的三大推导式

• 列表推导式
  根据已有列表推导出新的列表

list= [1,2,3,4,5,6]
list1 = [i+i for i in list]
print(list1)
#[2, 4, 6, 8, 10, 12]
list2=[i+i for i in list if i>3]#有选择性的筛选
print(list2)
[8, 10, 12]

• 集合推导式
  同上

list= {1,2,3,4,5,6}
list1 = {i+i for i in list}
print(list1)
#{2, 4, 6, 8, 10, 12}
list2={i+i for i in list if i>3}#有选择性的筛选
print(list2)
{8, 10, 12}

• 字典推导式

s={
    'z':20,
    'l':15,
    'w':31
}
s_key = [key+'aaa' for key,value in s.items()]#拿出所有的key与‘aaa’拼接，并变成列表
print(s_key)
#['zaaa', 'laaa', 'waaa']
s1 = {value:key for key,value in s.items()}#key和value的位置颠倒
print(s1)
#{20: 'z', 15: 'l', 31: 'w'}
#进行条件选择时同上即可

numpy的文件操作

numpy中常用np.save和np.load进行读写数据，默认拓展名为.npy，压缩后文件的拓展名为.npz

import numpy as np
arr = np.arange(10)
np.save('a_array',arr)
np.load('a_array.npy')
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.savez('a_array1',a=arr)#保存成一个压缩文件，数组以关键字参数的形式传入,这里后缀.txt可以写可以不写，但是保存txt必须写后缀
np.load('a_array1.npz')['a']
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#也可以将numpy保存为txt文件
np.savetxt('a_array2.txt',arr,delimiter=',')#保存成一个txt文件，分隔符为，
np.loadtxt('a_array2.txt',delimiter=',')
#array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

pandas篇

pandas有使数据分析工作变得更快更简单的高级数据结构和操作工具

pandas里面有两种数据类型：series和dataframe
pandas可以进行reindex(重新索引),method可以设置none时的填充方法，fill：填充方法为nan；ffill：前项填充；bfill：后项填充；

数据的运算

1. Series进行运算

重叠的地方相加减，不重叠的地方NaN填充

d1 = Series([1.3,1.5,2.6,-3.5],index = ['a','b','c','d'])
d2 = Series([-1.3,-1.5,-1.6,3.9,9.8],index=['a','b','c','d','e'])
print(d1+d2)
'''
a    0.0
b    0.0
c    1.0
d    0.4
e    NaN
'''

2. DataFrame进行运算

pandas可以对不同索引对象进行算数运算，将dataframe对象相加，结果的索引是该索引的并集；默认用nan来填充；若规定fill_value=0,则用0来填充，且两者均空时才用nan填充

df1 = DataFrame(np.arange(9).reshape(3,3),columns=list('abc'),index=[1,2,3])
print(df1)
df2 = DataFrame(np.arange(12).reshape((4,3)),columns=list('cde'),index=[1,2,3,4])
print(df2)
print(df1+df2)
'''
   a  b  c
1  0  1  2
2  3  4  5
3  6  7  8
   c   d   e
1  0   1   2
2  3   4   5
3  6   7   8
4  9  10  11
    a   b     c   d   e
1 NaN NaN   2.0 NaN NaN
2 NaN NaN   8.0 NaN NaN
3 NaN NaN  14.0 NaN NaN
4 NaN NaN   NaN NaN NaN
'''
df1.add(df2,fill_value=0)
'''
     a    b     c     d     e
1  0.0  1.0   2.0   1.0   2.0
2  3.0  4.0   8.0   4.0   5.0
3  6.0  7.0  14.0   7.0   8.0
4  NaN  NaN   9.0  10.0  11.0
'''

3. datafrme与series进行运算

相减为广播相减；相加时，没有就合并；除并集外用NaN填充

frame = DataFrame(np.arange(12).reshape((4,3)),columns=list('cde'),index=[1,2,3,4])
print(frame)
series = Series(range(3),index=list('def'))
print(series)
print(frame-series)
'''
   c   d   e
1  0   1   2
2  3   4   5
3  6   7   8
4  9  10  11

d    0
e    1
f    2
dtype: int64
    c     d     e   f
1 NaN   1.0   1.0 NaN
2 NaN   4.0   4.0 NaN
3 NaN   7.0   7.0 NaN
4 NaN  10.0  10.0 NaN
'''

Series

series是一组类似一维数组的对象，由一组数据以及这组数据的索引构成，索引默认从零开始递增，也可以自定义索引

#==自定义索引===
from pandas import Series,DataFrame
obj = Series(['a','b','c','d','e'],index=[1,2,3,4,5])
print(obj)
'''
1    a
2    b
3    c
4    d
5    e
dtype: object
'''

series也可以当字典用：

data = {'a':1000,'b':2000,'c':3000}
obj = Series(data)
print(obj)
keys = ['a','c']
obj1 = Series(data,index = keys)
print(obj1)
'''
a    1000
b    2000
c    3000
dtype: int64
a    1000
c    3000
dtype: int64
'''

对缺失数据的处理：缺失数据显示NaN

DataFrame

DataFrame是一个表格型数据结构，列有序，每列可以是不同值的类型，数值、字符串、布尔值都可以；dataframe有行索引和列索引；可以理解为是由series组成的一个字典；

可以接收的类型：
（1）由数组、列表、元组构成的字典
（2）二维numpy_array
（3）Series组成的字典
（4）由字典组成的字典
（5）字典或Series列表
（6）有列表或者元组组成的列表
（7）另一个dataframe

对DataFrame进行排序，默认对行排序，也可以指定轴frame.sort_index(axis=?)进行排序；或者frame.sort_values(by=‘?’)指定那个轴进行排序；

读写文件

读写csv 文件

• pd.read_csv():默认将第一行数据作为head，若想全为数据加一个参数head=none；其他参数：
  index_col:指定索引列
  skiprows=[？]:跳过第？行
  nrows=n:读n行
• data.to_csv():such as, data.to_csv(‘data1.csv’,sep=‘|’):将data数据写到csv文件中，以‘｜’作为分隔符
• read_fwf:读取固定宽列格式数据
• read_clipboard:读剪切板中的数据，可以看作是read table的剪切板。在将网页中的数据转换为表格中数据时会用到

读取excel文件

pd.read_excel():参数sheet_name=''可以用来加表名