实训笔记20190805--pandas

pandas中主要有两种数据结构，分别是：Series和DataFrame。

series

1. Series：一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。注意：Series中的索引值是可以重复的。
2. DataFrame：一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引也有列索引，可以被看做是由Series组成的字典
   结论:DataFrame是一个多维数组,

import pandas as pd
import numpy as np
#企业命名规范

ser01=pd.Series([1,2,3,4,5])
print('series数据的值:',ser01.values)
print('series的索引值:',ser01.index)
print('series的数据类型:',ser01.dtype)
#series的数据类型完全遵守numpy的数据类型
print(ser01)

#利用series创建一个二位数组
ser02=pd.Series(np.array([[1,2,3,4],[1,2,3]]))
#表示的是将numpy里面的array创建多维数组的方法,嵌套到series里面,用于创建多个维度数
print('series数据的值:',ser02.values)
print('series的索引值:',ser02.index)
print('series的数据类型:',ser02.dtype)
print(ser02)

#为索引index创建一个名称
ser03=pd.Series([100,99,92,69])
ser03.index=[u'数学',u'语文',u'化学',u'英语']
#u表示的是一个标识符关键字和索引位置是一样的
print(ser03)

#企业的另一种写法:
ser04=pd.Series(data=[100,54,67,78],dtype=np.float,index=['数学','语文','化学','英语'])
print(ser04)

ser05=pd.Series([[1,2,3],[3,4,5]])
print(ser05)

#通过字典创建一个series多维数组
dict01=({'1001':'milong','1002':'ruohao','1003':'yuanyuan','1004':'taotao','1005':'kaikai'})
ser06=pd.Series(dict01)
print(ser06)
print('通过dict创建的类型:',ser06.values)#暗含通过key值,只打印值,不打印key,打印key不安全
print('通过dict创建的类型:',ser06.index)#通过字典创建的index,其实就是key

series数据的值: [1 2 3 4 5]
series的索引值: RangeIndex(start=0, stop=5, step=1)
series的数据类型: int64
0    1
1    2
2    3
3    4
4    5
dtype: int64

series数据的值: [list([1, 2, 3, 4]) list([1, 2, 3])]
series的索引值: RangeIndex(start=0, stop=2, step=1)
series的数据类型: object
0    [1, 2, 3, 4]
1       [1, 2, 3]
dtype: object

数学    100
语文     99
化学     92
英语     69
dtype: int64

数学    100.0
语文     54.0
化学     67.0
英语     78.0
dtype: float64

0    [1, 2, 3]
1    [3, 4, 5]
dtype: object

1001      milong
1002      ruohao
1003    yuanyuan
1004      taotao
1005      kaikai
dtype: object

结果:Series通过下标index可以获取值,并且Series是创建一个一维数组

1. 在pandas里面下标,索引一般叫做数据标签(数据标签是我们在AI,Python数据分析,大数据,数据挖掘里面获取数据集的核心标签)
   数据标签不分数据的大小,1行数据也可以通过数据标签获取,海量数据也可以通过数据标签获取—企业大量使用
2. 因为series只能创建一维数组,如果想创建二维数组,那么就必须导入numpy模块.利用np.array(多维数组)—形成维度空间(矩阵)
3. ser03,index=[u’数学’,u’语文’,u’化学’,u’英语’]此写法不写index,直接给index赋列值
4. ser04=pd.Series(data=[100,54,67,78],dtype=np.float,index=[‘数学’,‘语文’,‘化学’,‘英语’])
   ser04里面有4个参数,data是数据,dtype=是根据项目数据要求定制数据类型,因为series默认的是整型index直接赋值
   备注:不建议data和index分开来写,建议第四种写法

Series值的获取

获取series值得几种方法

1. 通过[]+index 快速,但是直接操作index对数据是不安全的–结合情况适用
2. 通过[]+下标值 如果要进行数据的CRUD操作,建议使用该方法
3. 通过numpy的ndarray的切片操作:括号+下标值/索引值+冒号(?

#第一种方法
ser01=pd.Series([1,2,3,4])
ser01.index=['a','b','c','d']
print(ser01['c'])
#第二种方法
ser02=pd.Series(['a','b','c','d'])
print(ser02[2])
#第三种方法
ser03=pd.Series(['a','b','c','d'])
print(ser03[0:2])

3
c
0    a
1    b
dtype: object

series的运算

series 支持numpy和Python两者的运算

ser11=pd.Series({'1001':100,'1002':200,'1003':300,'1004':400})
print('进行运算前的值')
print(ser11)
print('运算之后的值:')
#逻辑判断
print(ser11[ser11>150])
print('进行逻辑运算之后:')
print(ser11/100)

ser12=([-1,-2,-3,4,5,6])
ser13=np.exp(ser12)
print('底数操作之后的值:',ser13)

进行运算前的值
1001    100
1002    200
1003    300
1004    400
dtype: int64

运算之后的值:
1002    200
1003    300
1004    400
dtype: int64

进行逻辑运算之后:
1001    1.0
1002    2.0
1003    3.0
1004    4.0
dtype: float64

底数操作之后的值: [3.67879441e-01 1.35335283e-01 4.97870684e-02 5.45981500e+01
 1.48413159e+02 4.03428793e+02]

series的缺省值检测

和赋值有什么区别?

1. 没有被赋值,
2. 缺失----程序不会报空指针异常,也不会报程序异常,会用NAN填充

pandas中的isnull和notnull两个函数可以用于在Series中检测缺失值，这两个函数的返回时一个布尔类型的Series

#缺省值检测
ser16=pd.Series({'1001':'a','1002':'b','1004':'d','1005':'e'})
print('检查缺省值之前的:',ser16)
ser17=pd.Series(ser16,index=['1001','1002','1003'])
print('检查缺省之后的值:',ser17)
print(pd.isnull(ser17))
print(pd.notnull(ser17))

检查缺省值之前的: 1001    a
1002    b
1004    d
1005    e
dtype: object

检查缺省之后的值: 1001      a
1002      b
1003    NaN
dtype: object

1001    False
1002    False
1003     True
dtype: bool

Series自动对齐

当多个series对象之间进行运算的时候，如果不同series之间具有不同的索引值，那么运算会自动对齐不同索引值的数据，如果某个series没有某个索引值，那么最终结果会赋值为NaN。

自动对齐是基于一个列表元素或则一个多维数组----矩阵/矩阵乘积
原理:去通过series自动匹配index所对应的值,日过有匹配的值和index,按照原始数据打印数据
如果对应的位置没有对应

ser18=pd.Series([1,2,3,4],index=['a','b','c','d'])
ser19=pd.Series([10,20,30,40],index=['a','b','c','d'])
print(ser18+ser19)
ser191=pd.Series([10,20,30,40],index=['a','e','c','d'])
print(ser18+ser191)

a    11
b    22
c    33
d    44
dtype: int64
a    11.0
b     NaN
c    33.0
d    44.0
e     NaN
dtype: float64

series的name属性

Series对象本身以及索引都具有一个name属性，默认为空，根据需要可以进行赋值操作

1. ser20.name=‘明星’
   直接调用name属性,不方便数据的阅读,不方便程序员去解析数据,不建议直接调用name属性
2. ser20.index.name=‘大咖’
   =>利用index索引从当列名称,其实是非常正确的,因为键key对应的是一个index,index属性的值在列的第一位置,列的第一列----就是一个数据的title,数据阅读起来很清晰,数据解析很明确

ser20=pd.Series({'1001':'milong','1002':'ruohao','1003':'yuanyuan','1004':'taotao','1005':'kaikai'})
ser20.name='明星'
ser20.index.name='大咖'
print(ser20)

大咖
1001      milong
1002      ruohao
1003    yuanyuan
1004      taotao
1005      kaikai
Name: 明星, dtype: object

DataFrame:通过二维数组创建

1. DataFrame的index和columns属性一定使用
2. 重置index的值,

df01=pd.DataFrame([['1001','1002','1003'],['milong','yuanyuan','ruohao']])
print(df01)
print()
df02=np.array([['wang',32],
                      ['li',29],
                      ['zhang',31]])
df03=pd.DataFrame(df02,index=['one','two','three'],columns=['name','age'])
print(df03)
print('index的值:',df03.index)
print('values的值:',df03.values)
print('columns的值:',df03.columns)


#通过DataFrame创建一个矩阵
df04={
    'pid':['1001','1002','1003','1004'],
    'age':[12,23,34,45,],
    'month':['8月','9月','10月','11月'],
    'year':[2016,2017,2018,2019]
}
df05=pd.DataFrame(df04)
print(df05)

#重置
df05=pd.DataFrame(df04)
df05.index=['wang','li','zhang','zhao']
print(df05)

        0         1       2
0    1001      1002    1003
1  milong  yuanyuan  ruohao

        name age
one     wang  32
two       li  29
three  zhang  31
index的值: Index(['one', 'two', 'three'], dtype='object')
values的值: [['wang' '32']
 ['li' '29']
 ['zhang' '31']]
columns的值: Index(['name', 'age'], dtype='object')

    pid  age month  year
0  1001   12    8月  2016
1  1002   23    9月  2017
2  1003   34   10月  2018
3  1004   45   11月  2019

        pid  age month  year
wang   1001   12    8月  2016
li     1002   23    9月  2017
zhang  1003   34   10月  2018
zhao   1004   45   11月  2019

索引对象

就是不直接操作index,而是将index通过其他数据标签进行操作数据的完整过程,数据完全可以读写操作!
例如:index == key == ser01 =([‘one’[,‘two’,‘three’])

索引对象也可以利用面向对象思想理解–万物皆为对象–可以利用任何数据标签充当index操作数据
不管是Series还是DataFrame对象，都有索引对象

数据抓取方法如下:

1. 直接通过列索引获取指定列的数据. eg:df03.name
2. 添加数据给列.注意:原始数据有几列,若新添加数据应大于原数据列数量,报错不汽配

删除列数据: 利用pop()函数

修改列数据:直接通过字段名称,赋值修改

行数据:

1. 如需要指定行的数据,需要通过ix方法获取对应行索引的行数据(此方法过时,但可以使用)
2. 新方法:loc
3. 添加行:ix[] ==>df02.ix[4]=[‘Tim’,200]
4. 行数据修改: index
5. 真删改都可以使用loc

df02=pd.DataFrame([['Tom',76],['joker',45],['black',35],['rose',56]],columns=['姓名','年龄'])
print(df02['姓名'])

print(df02)

df02['地点']=['北京','香港','南京','广州']
print(df02)

print('删除列数据:')
df02.pop('年龄')
print(df02)

print('修改列数据:')
df02['地点']='啦啦啦'
print(df02)

0      Tom
1    joker
2    black
3     rose
Name: 姓名, dtype: object

      姓名  年龄
0    Tom  76
1  joker  45
2  black  35
3   rose  56

      姓名  年龄  地点
0    Tom  76  北京
1  joker  45  香港
2  black  35  南京
3   rose  56  广州

删除列数据:
      姓名  地点
0    Tom  北京
1  joker  香港
2  black  南京
3   rose  广州

修改列数据:
      姓名   地点
0    Tom  啦啦啦
1  joker  啦啦啦
2  black  啦啦啦
3   rose  啦啦啦

print('获取行数据:')
#df02.ix[0]
print(df02.loc[0])

print(df02.loc[0,'姓名'])
print(df02.loc[[0],['姓名']])

print('添加行数据:')
df02.loc[4]=['zhangtao',200]
print(df02)

获取行数据:
姓名    Tom
地点    啦啦啦
Name: 0, dtype: object

Tom
    姓名
0  Tom

添加行数据:
         姓名   地点
0       Tom  啦啦啦
1     joker  啦啦啦
2     black  啦啦啦
3      rose  啦啦啦
4  zhangtao  200

numpy补充

import numpy as np
'''
    NumPy - 统计函数
    NumPy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等
'''

'''
    Nump.main  numpy.amax
    这些函数从给定数组中的元素沿指定轴返回最小值和最大值。
    
'''
# a = np.random.randint(1,15,size = (3,3))
a = np.array([[1,2,3,4],[7,8,9,10]])
'''
    random模块
    rand  返回 0 - 1 随机值
    randn 返回一个样本具有标准正态分布
    randint 返回随机的整数，位于半开区间[low,hight)size = 10  (3,3)
    random_integers(low[, high, size])  返回随机的整数，位于闭区间
    random 返回随机浮点数
'''
print(a)
#amin返回最小值
print('------------amin 返回最小值-------------')
print(np.amin(a,1)) #参数1 表示同行数据
print(np.amin(a,0)) #参数0 表示同列数据
#amax返回最大值
print('------------amax 返回最大值-------------')
print(np.amax(a,1))#a=array里面的max同行最大值
print(np.amax(a,0))#同列最小值

#mean 平均值
print('------------mean 平均值-------------')
print(np.mean(a))
print(np.mean(a,0)) #求列平均值
print(np.mean(a,axis = 1)) #求行平均值

'''
    标准差  是与平均值的偏差的平方的平均值的平方根
    std = sqrt(mean((x-x.mean())**2))
    如果数组是[1,2,3,4] 则平均值是 2.5 因此偏差是[1.5,0.5,0.5,1.5],
    偏差的平方是[2.25,0.25,0.25,2.25]
    并且其平均值的平方根，即sqrt(5/4)
'''
arr2 = np.array([[1,2,3,4],[7,8,9,10]])
print(arr2)
# print(arr2-arr2.mean()) #平均值的偏差
print(((arr2-arr2.mean())**2).sum()/arr2.size)#平均值的偏差的平方的平均值
print(np.mean(((arr2-arr2.mean())**2)))#平均值的偏差的平方的平均值
print(np.sqrt(((arr2-arr2.mean())**2).sum()/arr2.size))
print(np.sqrt(np.mean(((arr2-arr2.mean())**2))))
print(np.std(arr2,0))
print('************************')
'''
    方差
    方差是偏差的平方的平均值即mean(x-x.mean()**2)
'''
arr3 = np.array([[1,2,3,4],[7,8,9,10]])
# print(np.var(arr3))
# print(arr3-arr3.mean())
print(((arr3-arr3.mean())**2).sum()/arr3.size)
print(np.mean((arr3-arr3.mean())**2))
print(np.var(arr3))

[[ 1  2  3  4]
 [ 7  8  9 10]]
------------amin 返回最小值-------------
[1 7]
[1 2 3 4]
------------amax 返回最大值-------------
[ 4 10]
[ 7  8  9 10]
------------mean 平均值-------------
5.5
[4. 5. 6. 7.]
[2.5 8.5]
[[ 1  2  3  4]
 [ 7  8  9 10]]
10.25
10.25
3.2015621187164243
3.2015621187164243
[3. 3. 3. 3.]
************************
10.25
10.25
10.25