人工智能实践——pandas

pandas.Series

可看成一个定长的有序字典，通过shape,size,index,values可得到其属性
可通过head(),tail()快速查看其对象样式
当索引没有对应值时，显示NaN
检测缺失数据：pd.isnull(),pd.notnull或自带的isnull(),notnull()
Series对象本身及其索引都有一个name值
#导入Pandas包
import pandas as pd
#创建Series
#1.1.1 通过列表List
listSer=pd.Series([10,20,30,40])
print(listSer)

0 10
1 20
2 30
3 40

#1.1.2 通过字典dict
dictSer=pd.Series({‘a’:10,‘b’:40,‘c’:5,‘d’:90,‘e’:35,‘f’:40},name=‘数值’)
print(dictSer)

a 10
b 40
c 5
d 90
e 35
f 40

#1.1.3 通过array
import numpy as np
arrySer=pd.Series(np.arange(10,15),index=[‘a’,‘b’,‘c’,‘d’,‘e’])

#查找行列标
#index
print(arrySer.index)
#values
print(arrySer.values)

Index([‘a’, ‘b’, ‘c’, ‘d’, ‘e’], dtype=‘object’)
[10 11 12 13 14]

#iloc通过位置获取数据
print(arrySer[0:1]) #相当于dictSer.iloc[0:1]

a 10

#loc通过索引获取数据
print(arrySer[[‘a’,‘b’]]) #相当于dictSer.loc[[‘a’,‘b’]]
a 10
b 11
#boolean indexing获取值
print(arrySer[arrySer.values<=10]) #获取值不超过10的数据
print(arrySer[arrySer.index!=‘a’]) #获取索引值不是a的数据
a 10

b 11
c 12
d 13
e 14

print(arrySer.describe())
print(arrySer.mean()) #均值
arrySer.median() #中位数
arrySer.sum() #求和
arrySer.std() #标准差
arrySer.mode() #众数
arrySer.value_counts() #每个值的数量

count 5.000000
mean 12.000000
std 1.581139
min 10.000000
25% 11.000000
50% 12.000000
75% 13.000000
max 14.000000

#连接两个Series
#两个Series共同拥有的可以计算，不是的话NaN
dictSer2=pd.Series({‘a’:10,‘b’:20,‘d’:23,‘g’:90,‘h’:35,‘i’:40},name=‘数值’)
dictSer3=dictSer2+arrySer
print(dictSer3)

a 20.0
b 31.0
c NaN
d 36.0
e NaN
g NaN
h NaN
i NaN

#找出空/非空值
print(dictSer3[dictSer3.notnull()]) #非空值

a 20.0
b 31.0
d 36.0

dictSer3[dictSer3.isnull()] #空值
#填充空值
dictSer3=dictSer3.fillna(dictSer3.mean()) #用均值来填充缺失值
print(dictSer3)

#删除值
dictSer3=dictSer3.drop(‘b’)
print(dictSer3)

a 20.0
c 29.0
d 36.0
e 29.0
g 29.0
h 29.0
i 29.0

DataFrame 数据帧

可以看做是多个Series的组合
创建方法一：来自 Series 的 dict 或 dicts

d = {‘one’: pd.Series([1., 2., 3.], index=[‘a’, ‘b’, ‘c’]),
…: ‘two’: pd.Series([1., 2., 3., 4.], index=[‘a’, ‘b’, ‘c’, ‘d’])}
one two
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d NaN 4.0

创建方法二：来自DataFrame
pd.DataFrame(d, index=[‘d’, ‘b’, ‘a’,‘f’])
one two
d NaN 4.0
b 2.0 2.0
a 1.0 1.0
f NaN NaN
pd.DataFrame(d, index=[‘d’, ‘b’, ‘a’], columns=[‘two’, ‘three’])

two three
d 4.0 NaN
b 2.0 NaN
a 1.0 NaN
#可以看到，当从旧创新时，如果时，会根据传入的index,columns构建新的，并且会继承原有的index,columns的对应值，如果无法对应，则为NaN

创建方法三：从list中创建
d = {‘one’: [1., 2., 3., 4.],
‘two’: [4., 3., 2., 1.]}

print(d)#{‘one’: [1.0, 2.0, 3.0, 4.0], ‘two’: [4.0, 3.0, 2.0, 1.0]}

pd.DataFrame(d, index=[‘a’, ‘b’, ‘c’, ‘d’])
one two
a 1.0 4.0
b 2.0 3.0
c 3.0 2.0
d 4.0 1.0
#可以看到list相当于带了columns和value【注意和Series的区别，可以想象因为Serise是类字典，所以一定是一对一，而list可以一对多】
#并且也要注意，对于list如果新传入columns值，需按照创建方法二：来自DataFrame 处理，不是直接改变columns，而是对原DataFrame进行匹配

创建方法四：通过ndarrays

非结构化数组

d=np.array([[1,4],[2,3],[3,2],[4,1]])
d=pd.DataFrame(d,columns={“one”,“two”},index={‘a’,‘b’,‘c’,‘d’})
print(d)

ndarrays必须都是相同的长度。如果传递索引，则它必须明显与数组的长度相同。如果没有传递索引，结果将是range(n)，n数组长度【即0，1,2，3】

结构化数组

data = np.zeros((2, ), dtype=[(‘A’, ‘i4’), (‘B’, ‘f4’), (‘C’, ‘a10’)])
data[:] = [(1, 2., ‘Hello’), (2, 3., “World”)]
pd.DataFrame(data)
A B C
0 1 2.0 b’Hello’
1 2 3.0 b’World’

pd.DataFrame(data, index=[‘first’, ‘second’], columns=[‘C’, ‘A’, ‘B’])

C A B
0 b’Hello’ 1 2.0
1 b’World’ 2 3.0

pandas的操作

d = {‘one’: [1., 2., 3., 4.],
‘two’: [4., 3., 2., 1.]}
df=pd.DataFrame(d,index={0,1,2,3})

1：查询
查询行标签：
df.index
Index([‘a’, ‘b’, ‘c’, ‘d’], dtype=‘object’)

查询列标签：
df.columns
Index([‘one’, ‘two’], dtype=‘object’)

查询某行：[会携带列标签]
df.loc[0]
查询第几行
df.iloc[1]

查询某列：[会携带行标签]
df[“one”]

2：增
增加某列：
df[‘three’] = df[‘one’] * df[‘two’]
df[‘flag’] = df[‘one’] > 2
df[‘ada’]={1,2,3,4}

增加某行：
df.loc[4]=[1,2,3,True,5]

one two three flag ada
0 1.0 4.0 4.0 False 1
1 2.0 3.0 6.0 False 2
2 3.0 2.0 6.0 True 3
3 4.0 1.0 4.0 True 4
4 1.0 2.0 3.0 True 5
#一定注意增加某行和某列时，一定要与长度匹配

插入某列：在第i列处插入[插入后充当第i列]
df.insert(1, ‘bar’, df[‘one’])
df.insert(1, ‘bar’, df[‘one’][0:2])#此处因为没有对齐，会自动填充NaN

插入某行：
df = df.reindex(index=df.index.insert(2, ‘5’))
df.loc[‘5’] = [16, 17]

3：删
删除列：
del df[‘two’]
df=df.drop([“flag”],axis=1)
three = df.pop(‘three’)

删除行：
df=df.drop([0])

one ada
0 1.0 1
1 2.0 2
2 3.0 3
3 4.0 4
4 1.0 5
#要注意有的是返回一个修改的对象，有的是在原值上修改。最好使用df=df.drop(,)

4：改
修改某行
df.loc[0]
修改第几行
df.iloc[1]

修改某列
df[“one”]

不再原值上修改而只是得到一个副本：
d={‘one’: [1., 2., 3., 4.],
‘two’: [4., 3., 2., 1.]}
da=pd.DataFrame(d)
db=pd.DataFrame(np.array([[2,3],[4,5],[6,7],[1,2]]),columns={“new1”,“new2”})
dc=(df.assign(sepal_ratio=db[‘new1’] / db[‘new2’])
其中sepal-ration是列名，=后面既可以为df的列值也可以是其他DataFrame的列值
one two three flag ada sepal_ratio
0 1.0 4.0 4.0 False 1 0.666667
1 2.0 3.0 6.0 False 2 0.800000
2 3.0 2.0 6.0 True 3 0.857143
3 4.0 1.0 4.0 True 4 0.500000

5：多个对象的操作
1：DataFrame和DataFrame 需要数据对齐，否则NaN
df = pd.DataFrame(np.random.randn(10, 4), columns=[‘A’, ‘B’, ‘C’, ‘D’])
df2 = pd.DataFrame(np.random.randn(7, 3), columns=[‘A’, ‘B’, ‘C’])
print(df + df2)

      A         B         C   D

0 -1.985911 -1.237636 -1.432043 NaN
1 -0.488834 -1.282736 0.203651 NaN
2 -0.767187 -0.254880 1.586534 NaN
3 -0.796909 0.040980 1.825259 NaN
4 0.072990 1.014819 1.813898 NaN
5 -1.013695 -0.668574 0.190492 NaN
6 2.016595 -1.299800 0.287957 NaN
7 NaN NaN NaN NaN
8 NaN NaN NaN NaN
9 NaN NaN NaN NaN

2:DataFrame和Series之间，默认广播。默认是行对齐后列重复
注意点：
（1）行对齐必须是行名对齐，只有相同行名才能操作！【所有DataFrame都是】
（2）如果行没有对齐，则为NaN
df = pd.DataFrame(np.ones([3,4]), columns=[‘A’, ‘B’, ‘C’, ‘D’])
de = pd.DataFrame(np.ones([3,3]),columns=[‘A’, ‘B’, ‘C’])
df=df - de.iloc[0]
print(df)
A B C D
0 0.0 0.0 0.0 NaN
1 0.0 0.0 0.0 NaN
2 0.0 0.0 0.0 NaN

df = pd.DataFrame(np.ones([3,4]), columns=[‘A’, ‘B’, ‘C’, ‘D’])
de = pd.DataFrame(np.ones([3,3]),columns=[‘E’, ‘F’, ‘G’])
df=df - de.iloc[0]
print(df)
A B C D E F G
0 NaN NaN NaN NaN NaN NaN NaN
1 NaN NaN NaN NaN NaN NaN NaN
2 NaN NaN NaN NaN NaN NaN NaN

6：标量操作
DataFrame可以化为标量执行±/ 等操作，相当于是对每一个元素分别进行操作
例如df=df1+1 df=dfdf
同时布尔运算符也可以生效
d1=pd.DataFrame(np.array([[1,1,0],[1,1,1]]))
d2=pd.DataFrame(np.array([[0,1,0],[0,0,1]]))
d=d1&d2
print(d)
0 1 2
0 0 1 0
1 0 0 1

7：np函数使用
DataFrame和Series可以使用np的函数如(exp,log,sqrt，round,floor,ceil)等
df = pd.DataFrame(np.ones([3,4]), columns=[‘A’, ‘B’, ‘C’, ‘D’])
df=np.exp(df)
print(df)
df=np.log(df)
print(df)
df=np.round(df,-1)
print(df)
A B C D
0 2.718282 2.718282 2.718282 2.718282
1 2.718282 2.718282 2.718282 2.718282
2 2.718282 2.718282 2.718282 2.718282
A B C D
0 1.0 1.0 1.0 1.0
1 1.0 1.0 1.0 1.0
2 1.0 1.0 1.0 1.0
A B C D
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0

文件的读取和转化

DataFrame 转化为Series
n=df.values 【注意是DataFrame的方法而不是类方法】

txt:文件
a,b,c,d,name
1,2,3,4,python
5,6,7,8,java
9,10,11,12,c++

read_csv 从文件、URL、文件新对象中加载带有分隔符的数据，默认分隔符是逗号
可以从txt也可以从csv，注意如果从txt读
read_csv:换行符为行标志, ',‘为分隔符
read_table:换行符为行标志，’/t’为分隔符

也要注意，默认第一行为行标签，无列标签
data = pd.read_csv(“out.txt”)
print(data)
输出：
　a b c d name
0 1 2 3 4 python
1 5 6 7 8 java
2 9 10 11 12 c++

data = pd.read_csv(“out.txt”,header=None,names=[“a”,“b”,“c”,“d”,“e”])
print(data)

a b c d e
0 a b c d name
1 1 2 3 4 python
2 5 6 7 8 java
3 9 10 11 12 c++

存储csv
pd.to_csv("",header=False,index=False)