数据分析---数据处理工具pandas（一）

数据分析—数据处理工具pandas（一）

一、Pandas数据结构Series

1.Series简介

# Series 是带有标签的【一维】数组，可以保存任何数据类型（整数，字符串，浮点数，Python对象等）,轴标签统称为索引

import numpy as np
import pandas as pd 

s = pd.Series(np.random.rand(5))
print(s)

# 核心：series相比于ndarray，是一个自带索引index的数组 → 即series为一维数组 + 对应索引
# 所以当只看series的值的时候，就是一个ndarray
# series和ndarray较相似，索引切片功能差别不大
# series和dict相比，series更像一个有顺序的字典（dict本身不存在顺序），其索引原理与字典相似（一个用key，一个用index）

2.Series的建立

（1）Series 创建方法一：由字典创建

# Series 创建方法一：由字典创建，字典的key就是index，values就是values

dic = {'a':1 ,'b':2 , 'c':3, '4':4, '5':5}
s = pd.Series(dic)
print(s)
# 注意：key肯定是字符串，假如values类型不止一个会怎么样？ 答案是可以，但是series的类型会改变
dic2 = {'a':1 ,'b':'hello' , 'c':3, '4':4, '5':5}
s = pd.Series(dic2)
print(s)

# 结果:
a    1
b    2
c    3
4    4
5    5
dtype: int64
a        1
b    hello
c        3
4        4
5        5
dtype: object

（2）Series 创建方法二：由数组创建(一维数组)

# Series 创建方法二：由数组创建(一维数组)

ar = np.random.rand(5)
s = pd.Series(ar)
print(s)

# 结果：
0    0.929037
1    0.099647
2    0.576373
3    0.689908
4    0.908461
dtype: float64

（3）Series 创建方法三：由标量创建

# Series 创建方法三：由标量创建
# 如果data是标量值，则必须提供索引。该值会重复，来匹配索引的长度
s = pd.Series(4, index=range(4))   # index用来设置其下标的索引。index的元素个数决定了Series的元素个数
print(s)

a = pd.Series(3, index=['a', 'b', 'c'])  # index可以是列表、元组、集合
print(a)

# 结果：
0    4
1    4
2    4
3    4
dtype: int64
a    3
b    3
c    3
dtype: int64

3.Series 名称属性：name

# name为Series的一个参数，创建一个数组的 名称
# .name方法：输出数组的名称，输出格式为str，如果没用定义输出名称，输出为None
s = pd.Series(np.random.rand(5), name='test')
print(s)
s2 = s.rename('you')  # 更改数组的名字
print(s2)

# 结果：
0    0.051304
1    0.087069
2    0.520385
3    0.881301
4    0.217955
Name: test, dtype: float64
0    0.051304
1    0.087069
2    0.520385
3    0.881301
4    0.217955
Name: you, dtype: float64

4.数据结构Series：索引

主要有4个方面：位置下标 / 标签索引 / 切片索引 / 布尔型索引
（1）位置下标

# 位置下标，类似序列
s = pd.Series(np.random.rand(10))
print(s)
print(list(s.index))
print(s.values)
print(s[0])    # 注意：series不能负向索引，也就是不能s[-1]类似操作

# 结果：
0    0.714319
1    0.062221
2    0.151230
3    0.724606
4    0.579159
5    0.608105
6    0.714494
7    0.672469
8    0.768585
9    0.044062
dtype: float64
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0.71431919 0.06222059 0.15122966 0.72460598 0.57915893 0.60810476
 0.71449381 0.67246862 0.76858455 0.04406206]
0.7143191936948806

注意：series不能负向索引，也就是不能s[-1]类似操作
（2）标签索引

# 标签索引
# 方法1：
s = pd.Series(np.random.rand(5), index = ['a','b','c','d','e'])
print(s)
print(s[:2])  # 即使是index改变了，但是还是可以用数字0，1，...进行索引
# 方法2：
s2 = s[['a','b','c','d','e']]   # 不可以用s[[]]的方法去更改index,因为这里是切片
print(s2)
print('-----')

# 生成series后再更改标签
s = pd.Series(np.random.randint(5, size=3)) 
print(s)
s.index = ['a', 'b', 'c']
print(s)

# 结果：
a    0.453247
b    0.467157
c    0.383299
d    0.658244
e    0.538931
dtype: float64
a    0.453247
b    0.467157
dtype: float64
a    0.453247
b    0.467157
c    0.383299
d    0.658244
e    0.538931
dtype: float64
-----
0    3
1    0
2    3
dtype: int32
a    3
b    0
c    3
dtype: int32

（3）切片索引

# 切片索引
s1 = pd.Series(np.random.rand(5))
s2 = pd.Series(np.random.rand(5), index = ['a','b','c','d','e'])
print(s1[1:4])
print(s2['a':'c'])   # 注意：用index做切片是末端包含,也可以用s2.loc['a':'c']
print('-----')
print(s1[:-1])       # 注意：切片的时候，下标可以为负值
print(s2[::2])

# 结果：
1    0.772866
2    0.137175
3    0.678893
dtype: float64
a    0.091207
b    0.467405
c    0.498101
dtype: float64
-----
0    0.338393
1    0.772866
2    0.137175
3    0.678893
dtype: float64
a    0.091207
c    0.498101
e    0.593209
dtype: float64

（4）布尔型索引

# 布尔型索引

s = pd.Series(np.random.randint(5, size=3))
s[3] = None   # 添加一个空值
print(s)
bs1 = s > 3       # 数组做判断之后，返回的是一个由布尔值组成的新的数组
bs2 = s.isnull()  
bs3 = s.notnull()  # .isnull() / .notnull() 判断是否为空值 (None代表空值，NaN代表有问题的数值，两个都会识别为空值)
print(bs1)
print(bs2)
print(bs3)

print(s[s > 2])

# 结果：
0       3
1       0
2       1
3    None
dtype: object
0    False
1    False
2    False
3    False
dtype: bool
0    False
1    False
2    False
3     True
dtype: bool
0     True
1     True
2     True
3    False
dtype: bool
0    3
dtype: object

二、Pandas数据结构Series：基本技巧

1.添加元素

s1 = pd.Series(np.arange(3))
s2 = pd.Series(np.arange(10, 13), index = list('abc'))
print(s1)
print(s2)
# 添加一个元素
s1[3] = 100
s2['d'] = 100
print(s1)
print(s2)
print('-----')
# 将两个Series添加到一起
s3 = s2.append(s1)  # 通过.append方法，直接添加一个数组  .append方法生成一个新的数组，不改变之前的数组
print(s3)

# 结果：
0    0
1    1
2    2
dtype: int32
a    10
b    11
c    12
dtype: int32
0      0
1      1
2      2
3    100
dtype: int64
a     10
b     11
c     12
d    100
dtype: int64
-----
a     10
b     11
c     12
d    100
0      0
1      1
2      2
3    100
dtype: int64

2.删除元素

s = pd.Series(np.arange(5), index=list('abcde'))
print(s)
# 删除一个元素
s2 = s.drop('a')
print(s2)
print('-----')
# 删除多个元素
s3 = s.drop(['e', 'c'])
print(s3)

# 结果：
a    0
b    1
c    2
d    3
e    4
dtype: int32
b    1
c    2
d    3
e    4
dtype: int32
-----
a    0
b    1
d    3
dtype: int32

3.修改元素

s = pd.Series(np.arange(3)) # 不可以用s[[]]的方法去更改index
print(s)
s.index = ['a', 'b', 'c']
print(s)

# 结果：
0    0
1    1
2    2
dtype: int32
a    0
b    1
c    2
dtype: int32

4.查看元素

查看可以通过索引完成，这里介绍两个方法来查看元素：
s = pd.Series(np.arange(30))
print(s.head(10))  # .head()查看头部数据
print(s.tail())    # .tail()查看尾部数据, 默认查看5条

# 结果：
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int32
25    25
26    26
27    27
28    28
29    29
dtype: int32

5.重新索引reindex

# .reindex将会根据索引重新排序，如果当前索引不存在，则引入缺失值---默认用NaN补充
s = pd.Series(np.arange(10, 12), index=['a', 'b'])
print(s)
s2 = s.reindex(['b', 'a', 'c', 'd']) # reindex只是在已有的基础上重新排序，若没有的会用NaN补充
print(s2)

s3 = s.reindex(['b', 'a', 'c', 'd'], fill_value = 1) # 设置fill_value参数，可以用设置的数补充不存在的数
print(s3)

# 结果：
a    10
b    11
dtype: int32
b    11.0
a    10.0
c     NaN
d     NaN
dtype: float64
b    11
a    10
c     1
d     1
dtype: int32

reindex不仅可以作用于Series还可以作用于DataFrame，用reindex可以重新筛选、或者排列行/列标签，下面举一个作用于DataFrame的例子：
有数据names:

对其进行透视表操作：

table = names.pivot_table(values='births', index='last_letters', columns=['sex', 'year'], aggfunc=sum)

然后选出1910, 1960, 2010这几年：

subtable = table.reindex(columns=[1910, 1960, 2010], level='year')

6.Series对齐—把相同标签的值相加、相减…

s1 = pd.Series(np.arange(3), index = ['Jack','Marry','Tom'])
s2 = pd.Series(np.arange(10, 13), index = ['Wang','Jack','Marry'])
print(s1)
print(s2)
print(s1+s2)
# Series 和 ndarray 之间的主要区别是，Series 上的操作会根据标签自动对齐
# index顺序不会影响数值计算，以标签来计算
# 空值和任何值计算结果扔为空值

# 结果：
Jack     0
Marry    1
Tom      2
dtype: int32
Wang     10
Jack     11
Marry    12
dtype: int32
Jack     11.0
Marry    13.0
Tom       NaN
Wang      NaN
dtype: float64