Pandas是用于数据操纵和分析，建立在Numpy之上的。Pandas为Python带来了两种新的数据结构：Pandas Series和Pandas DataFrame，借助这两种数据结构，我们能够轻松直观地处理带标签数据和关系数据。
Pandas功能：
允许为行和列设定标签
可以针对时间序列数据计算滚动统计学指标
轻松处理NaN值
能够将不同的数据集合并在一起
与Numpy和Matplotlib集成
Series对象
Pandas series 是像数组一样的一维对象，可以存储很多类型的数据。Pandas series 和 Numpy array之间的主要区别之一是你可以为Pandas series 中的每个元素分配索引标签；另一个区别是Pandas series 可以同时存储不同类型的数据。
Series对象实际上都由两个数组组成,具有 index和 values两大属性。
index：保存标签信息,是从 NumPy数组继承的 Index对象；
values：保存值，是一维 NumPy数组对象。
1、同时指定index属性和value属性的具体值
2、仅制定values属性的值。如果只制定 values的取值,没有设定 index属性的取值,则会默认产生从0开始,步长为1,长度为 values
创建 Pandas Series
pd.Series(data, index)
groceries = pd.Series(data=[30, 6, 'yes', 'No'], index=['eggs', 'apples', 'milk', 'bread']) ser = pd.Series(data=[[0, 1, 2, 3], [1, 3, 5, 7], [2, 4, 6, 8]], index=(['a', 'b', 'c']))
注意：
1、 如果参数中只提供index值，未提供data，则会生成value全部为nan的空索引
2、 如果参数中只提供了data值，未提供index索引，则会生成index从0开始按顺序的数字索引
其它各种创建索引代码：
s1=pd.Series(np.random.randn(5))
s2=pd.Series([0,np.NaN,2,4,6,8,True, 10, 12])
s3=pd.Series({'a': 1,'b': 3,'c': 5,'d': 7})
s4=pd.Series([1,3,5,7,9], index=['a','b','c','d','e'])
查看 Pandas Series 属性
# Pandas Series 元素数量
print(groceries.size)
# Pandas Series 形状
print(groceries.shape)
# Pandas Series 维度
print(groceries.ndim)
# Pandas Series 索引列表
print(groceries.index)
# Pandas Series 元素列表
print(groceries.values)
查看是否存在某个索引标签：in
print('book' in groceries)
访问 Pandas Series 中元素
Pandas Series 提供了两个属性 .loc 和 .iloc
.loc 表明我们使用的是标签索引访问
.iloc 表明我们使用的是数字索引访问
# 标签索引
print(groceries['eggs'])
print(groceries[['eggs', 'milk']])
# 数字索引
print(groceries[1])
print(groceries[[1, 2]])
print(groceries[-1])
# 明确标签索引
print(groceries.loc['milk'])
print(groceries.loc[['eggs', 'apples']])
# 明确数字索引
print(groceries.iloc[0])
print(groceries.iloc[[0, 1]])
另外还有get函数，是专门根据索引获取值的：
Pandas Series.get()函数从给定键(DataFrame列，Panel slice等)的对象中获取项目。如果未找到，则返回默认值None;
返回值：
如果是单个key值查找，直接返回对应的值
如果是多个key同时查找，返回的是一个子Series对象
示例代码：
a = "I don't know how they've gotten away with all of that".split()
b = [91, 18, 27, 36, 15, 24, 33, 72, 31, 10, 56]
c = pd.Series(b, index = a)
print(c.get('all'))
print(c.get(['all','of']))
输出：
31
all 31
of 10
修改和删除元素
直接标签访问，值修改就可
groceries['eggs'] = 2
print(groceries)
删除：drop(参数 1：lable，标签；参数 2：inplace=True/False，是/否修改原 Series)
print(ser.drop(['b']))
print(ser.drop(['a', 'b'], inplace=True))
算术运算
Pandas Series执行元素级算术运算：加、减、乘、除
fruits = pd.Series(data=[10, 6, 3], index=['apples', 'oranges', 'bananas'])
# 所有数字进行运算
print(fruits + 2)
print(fruits - 2)
print(fruits * 2)
print(fruits / 2)
# 所有元素应用Numpy中的数学函数
print(np.exp(fruits))
print(np.sqrt(fruits))
print(np.power(fruits, 2))
# 部分元素进行运算
print(fruits[0] - 2)
print(fruits['apples'] + 2)
print(fruits.loc['oranges'] * 2)
print(np.power(fruits.iloc[0], 2))
时间序列介绍
时间序列类型也是一种 Series类型，与一般 Series对象不同的是，时间序列的 index属性取值为时间戳。
示例代码：
import pandas as pd
import numpy as np
#利用pandas生成日期数组作为索引，作为参数两边都会包含
date_idx=pd.date_range('2021/1/1','2021/12/31')
#新建时间序列索引
s=pd.Series(np.random.rand(len(date_idx)),index=date_idx)
#获取1到3月份的数据，注意切片时两头都会包含，和其它的切片不太一样
print(s['2021/1':'2021/3'])
说明：
1、时间序列的创建：方式与一般的 Series对象创建方式相同，我们只需要将 index设置为Timestamp对象。使用 to datetime()来将 Series的 index属性转换为 Datetimelndex:
2、截取时间段数据：一般的索引操作对时间序列依然有效，其特别之处在于对时间序列索引的操作优化。对于较长的序列，还可以只传入年份或年份加月份来选取切片：
3、滞后或超前操作
滞后操作指的是将t期的数据换成t一a期的数据，而超前操作自然是将t期的数据换成t+a期的数据。对于滞后或者超前操作,可以使用shift()方法。
排序
1、按索引进行排序
#定义一个Series
s = Series([1,2,3],index=["a","c","b"])
#对Series的索引进行排序，默认是升序
print(s.sort_index())
'''
a 1
b 3
c 2
'''
#对索引进行降序排序
print(s.sort_index(ascending=False))
'''
c 2
b 3
a 1
'''
2、按值进行排序
s = Series([np.nan,1,7,2,0],index=["a","c","e","b","d"])
#对Series的值进行排序，默认是按值的升序进行排序的
print(s.sort_values())
'''
d 0.0
c 1.0
b 2.0
e 7.0
a NaN
'''
#对Seires的值进行降序排序
print(s.sort_values(ascending=False))
'''
e 7.0
b 2.0
c 1.0
d 0.0
a NaN
'''
对值进行排序的时候，无论是升序还是降序，缺失值（NaN）都会排在最后面。
排名
排名和排序有点类似，排名会有一个排名值（从1开始，一直到数组中有效数据的数量），它与numpy.argsort的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系。
s = Series([1,3,2,1,6],index=["a","c","d","b","e"])
#默认是根据值的大小进行平均排名
'''
1是最小的，所以第一个1排在第一，第二个1排在第二
因为取的是平均排名，所以1的排名为1.5
'''
print(s.rank())
'''
a 1.5
c 4.0
d 3.0
b 1.5
e 5.0
'''
#根据值在数组中出现的顺序进行排名
print(s.rank(method="first"))
'''
a 1.0
c 4.0
d 3.0
b 2.0
e 5.0
'''
method参数除了,first按值在原始数据中的出现顺序分配排名，还有min使用整个分组的最小排名，max是用整个分组的最大排名，average使用平均排名，也是默认的排名方式。还可以设置ascending参数，设置降序还是升序排序。
DataFrame对象
Pandas DataFrame 是具有带标签的行和列的二维数据结构，可以存储多种类型的数据，类似于电子表格。
Dataframe：一个表格型的数据结构每一列代表一个变量，而每一行则是一条记录。简单地说，DataFrame是共享同一个 index的Series的集合。
在创建 DataFrame对象之前,要先创建一个索引。索引是一个 DataFrame对象必须有的元素，起到标识的作用。
1、手动创建数据
2、从其他地方读取数据：read_table（）函数、读取csv文件数据、读取MySQL数据。
创建 Pandas DataFrame
第一步：创建 Pandas Series 字典
第二步：将字典传递给 pd.DataFrame
items = {'Bob': pd.Series(data=[245, 25, 55], index=['bike', 'pants', 'watch']),
'Alice': pd.Series(data=[40, 110, 500, 45], index=['book', 'glasses', 'bike', 'pants'])}
shopping_carts = pd.DataFrame(items)
print(shopping_carts)
通过关键字 columns 和 index 选择要将哪些数据放入 DataFrame 中
shopping_cart = pd.DataFrame(items, index=['bike', 'pants'], columns=['Bob'])
print(shopping_cart)
访问、添加、删除 DataFrame
访问整列：dataframe[['column1', 'column2']]
# 读取列
print(shopping_carts[['Bob', 'Alice']])
访问整行：dataframe.loc[['row1', 'row2']]
# 读取行
print(shopping_carts.loc[['bike']])
访问某行某列：dataframe['column']['row']，先提供行标签，将出错。
# 读取某一列某一行
print(shopping_carts['Bob']['bike'])
take函数
Pandas dataframe.take()函数沿轴返回给定位置索引中的元素。这意味着我们没有根据对象的index属性中的实际值建立索引。我们正在根据元素在对象中的实际位置建立索引。
示例：
dataframe.take([2,4,0])
取第 3、5、1 三个值，如果按索引从0开始，则是2,4,0
添加整列（末尾添加列），空值用 None
# 添加列
shopping_carts['Mike'] = [10, 30, 10, 90, None]
添加整行（末尾添加行），把新添加行创建为 dataframe，通过 append() 添加
# 添加行
new_items = [{'Alice': 30, 'Bob': 20, 'Mark': 35, 'Mike': 50}]
new_store = pd.DataFrame(new_items, index=['store3'])
shopping_carts = shopping_carts.append(new_store)
只能删除整列：pop('lable')
# 删除整列
shopping_carts.pop('Jey')
删除行或者列：drop(['lable1', 'lable2'], axis=0/1) 0表示行，1表示列
# 删除行
shopping_carts = shopping_carts.drop(['store3', 'watch'], axis=0)
DataFrame更改行和列标签
rename()
# 更改列标签
shopping_carts = shopping_carts.rename(columns={'Bob': 'Jey'})
# 更改行标签
shopping_carts = shopping_carts.rename(index={'bike': 'hats'})
遍历
iterrows(): 将DataFrame迭代为(insex, Series)对。
iteritems(): 将DataFrame迭代为(列名, Series)对
itertuples(): 将DataFrame迭代为元祖。
示例代码：
import pandas as pd
inp=pd.DataFrame([{'c1':10,'c2':20},
{'c1':50,'c2':60},
{'c1':70,'c2':80}])
print(inp)
print('#'*50)
for idx,s in inp.iterrows():
print('idx',idx)
print(s)
print('#'*50)
for col_name,v in inp.iteritems():
print('col_name',col_name)
print(s)
print('#'*50)
for tu in inp.itertuples():
print(tu)
输出：
c1 c2
0 10 20
1 50 60
2 70 80
##################################################
idx 0
c1 10
c2 20
Name: 0, dtype: int64
idx 1
c1 50
c2 60
Name: 1, dtype: int64
idx 2
c1 70
c2 80
Name: 2, dtype: int64
##################################################
col_name c1
c1 70
c2 80
Name: 2, dtype: int64
col_name c2
c1 70
c2 80
Name: 2, dtype: int64
##################################################
Pandas(Index=0, c1=10, c2=20)
Pandas(Index=1, c1=50, c2=60)
Pandas(Index=2, c1=70, c2=80)
处理 NaN
统计 NaN 数量：isnull().sum().sum
# 数值转化为 True 或者 False
print(store_items.isnull())
# 每一列的 NaN 的数量
print(store_items.isnull().sum())
# NaN 总数
print(store_items.isnull().sum().sum())
统计非 NaN 数量：count(axis=0/1)
# 每一行非 NaN 的数量，通过列统计
print(store_items.count(axis=1))
# 每一列非 NaN 的数量，通过行统计
print(store_items.count(axis=0))
删除具有NaN值的行和列：dropna(axis=0/1, inplace=True/False) inplace默认False，原始DataFrame不会改变；inplace为True，在原始DataFrame删除行或者列
# 删除包含NaN值的任何行
store_items.dropna(axis=0)
# 删除包含NaN值的任何列
store_items.dropna(axis=1, inplace=True)
将 NaN 替换合适的值：fillna()
# 将所有 NaN 替换为 0
store_items.fillna(value=0)
# 前向填充：将 NaN 值替换为 DataFrame 中的上个值，axis决定列或行中的上个值
store_items.fillna(method='ffill', axis=1)
# 后向填充：将 NaN 值替换为 DataFrame 中的下个值，axis决定列或行中的下个值
store_items.fillna(method='backfill', axis=0)
加载数据
csv 格式文件，每一行都是用逗号隔开：read_csv()
# 读取 csv 文件，第一行作为列标签
data = pd.read_csv('data.csv')
print(data)
print(data.shape)
print(type(data))
读取前 N 行数据：head(N)
# 读取头 3 行数据
print(data.head(3))
读取最后 N 行数据：tail(N)
# 读取后 5 行数据
print(data.tail(5))
检查是否有任何列包含 NaN 值：isnull().any() 类型 bool
# 检查任何列是否有 NaN 值，返回值：bool
print(data.isnull().any())
数据集的统计信息：describe()
# 获取 DataFrame 每列的统计信息：count，mean，std，min，25%，50%，75%，max
# 25%：四分之一位数；50%：中位数；75%：四分之三位数
print(data.describe())
# 通过统计学函数查看某个统计信息
print(data.max())
print(data.median())
数据相关性：不同列的数据是否有关联，1 表明关联性很高，0 表明数据不相关。corr()
# 数据相关性
print(data.corr())
数据分组：groupby(['lable1', 'lable2'])
# 按年份分组，统计总薪资
data.groupby(['Year'])['Salary'].sum()
# 按年份分组，统计平均薪资
data.groupby(['Year'])['Salary'].mean()
# 按年份，部门分组，统计总薪资
data.groupby(['Year', 'Department'])['Salary'].sum()
索引与切片
将DataFrame中的某一列替换为索引:
df.set_index("period",inplace=True)
从现有的DataFrame中切出一个索引：
s1=pd.Series(df.loc['202012']['item'])
其中：’202012’代表索引过滤为202012的，item为具体需要新建索引的列（因为本质上Series对象即为DataFrame的某一列）
标签索引与切片：df.loc[row_ indexer, column_indexer]
位置索引与切片：df.iloc[row_ indexer, column_indexer]
shift函数
dataframe[“col”].shift(-1): 某列整体前（上）移 1 位，空缺出来的用Nan补齐
dataframe[“col”].shift(1): 某列整体后（下）移 1 位，空缺出来的用Nan补齐
行列转置
假设df是一个现成的DataFrame,一般使用df.T函数进行行列转置
df_T = pd.DataFrame(df.values.T,columns=index_row,index=index_colums)
print(df_T)
排序
1、 按索引进行排序
a = np.arange(9).reshape(3,3)
data = DataFrame(a,index=["0","2","1"],columns=["c","a","b"])
#按行的索引升序进行排序，默认按行，升序
print(data.sort_index())
'''
c a b
0 0 1 2
1 6 7 8
2 3 4 5
'''
#按行的索引按降序进行排序
print(data.sort_index(ascending=False))
'''
c a b
2 3 4 5
1 6 7 8
0 0 1 2
'''
#按列升序的索引进行排序
print(data.sort_index(axis=1))
'''
a b c
0 1 2 0
2 4 5 3
1 7 8 6
'''
#按列降序的索引进行排序
print(data.sort_index(ascending=False))
'''
c a b
2 3 4 5
1 6 7 8
0 0 1 2
'''
2、按值进行排序
a = [[9,3,1],[1,2,8],[1,0,5]]
data = DataFrame(a, index=["0", "2", "1"], columns=["c", "a", "b"])
#按指定列的值大小顺序进行排序
print(data.sort_values(by="c"))
'''
c a b
2 1 2 8
1 1 0 5
0 9 3 1
'''
print(data.sort_values(by=["c","a"]))
'''
c a b
1 1 0 5
2 1 2 8
0 9 3 1
'''
#按指定行值进行排序
print(data.sort_values(by="0",axis=1))
'''
b a c
0 1 3 9
2 8 2 1
1 5 0 1
'''
注意：对DataFrame的值进行排序的时候，我们必须要使用by指定某一行（列）或者某几行（列），如果不使用by参数进行指定的时候，就会报TypeError: sort_values() missing 1 required positional argument: 'by'。使用by参数进行某几列（行）排序的时候，以列表中的第一个为准，可能后面的不会生效，因为有的时候无法做到既对第一行（列）进行升序排序又对第二行（列）进行排序。在指定行值进行排序的时候，必须设置axis=1，不然会报错，因为默认指定的是列索引，找不到这个索引所以报错，axis=1的意思是指定行索引。
排名
排名和排序有点类似，排名会有一个排名值（从1开始，一直到数组中有效数据的数量），它与numpy.argsort的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系。
a = [[9, 3, 1], [1, 2, 8], [1, 0, 5]]
data = DataFrame(a, index=["0", "2", "1"], columns=["c", "a", "b"])
print(data)
'''
c a b
0 9 3 1
2 1 2 8
1 1 0 5
'''
#默认按列进行排名
print(data.rank())
'''
c a b
0 3.0 3.0 1.0
2 1.5 2.0 3.0
1 1.5 1.0 2.0
'''
#按行进行排名
print(data.rank(axis=1))
'''
c a b
0 3.0 2.0 1.0
2 1.0 2.0 3.0
1 2.0 1.0 3.0
'''
method参数和ascending参数的设置与Series一样。
数据规整化
数据规整的一般分类：
清理
转换
合并
重塑
Pandas数据规整-清理
对指定数据（如缺失数据、重复数据）进行处理（检查、替换、删除）
缺失值的表示：np.nan
检查缺失值：isnull(),notnull(),info()
删除缺失值：dropna()
填充缺失值：fillna()
替换值（填充缺失值是替换值的一种情况）：replace()
------------------------------
移除重复数据
检测和过滤异常值
实例代码：
a = np.array([2,4,5,7,8,9])
a + 10
# result array([12, 14, 15, 17, 18, 19])
b = np.array([None,1,4,6,8,4,23,67])
b + 10
# result TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
结论：缺失值导致报错
Numpy的缺失值数据类型：np.nan
缺失值运算不会报错，和缺失值进行运算，结果还是缺失值
a = np.array([np.nan,1,4,5])
a + 10
a.sum() # 任何数组和缺失值计算，结果还是缺失值
np.nansum(a)
np.nanmean(a) # result 3.3333333333333335 ,缺失值不参与运算
nan专有运算方法，会跳过缺失值，直接计算正常值,缺失值不参与运算
np.nansum(c)
np.nanmean(c)
使用Pandas缺失值计算
Pandas中，不论缺失值是 None 还是 np.nan ，都会转化为 NaN 的形式
NaN：非数字，not a number，Pandas中它表示缺失或NA值，便于被检测出来
本质上就是np.nan
Pandas的对象可以跳过缺失值直接进行运算
b = pd.Series([1,2,np.nan,4,None,6])
b+10
#reslut
#0 11.0
#1 12.0
#2 NaN
#3 14.0
#4 NaN
#5 16.0
b.mean() # 4.0
# 缺失值赋值
b[0] = np.nan
c = pd.DataFrame([[1,np.nan,3], [4,5,6], [np.nan,8,9]])
c.sum(axis=1)
是否含有缺失值
检查单个空值
单个空值，底层类型为 np.nan，不能直接比较是否相同
# 单个空值，底层类型为 np.nan，不能直接比较是否相同
np.nan == np.nan
# 单个np.nan空值，可以用 np.isnan() 方法判断是否是空值
np.isnan(np.nan)
# 整体判断，表格中各列缺失值情况
http://c.info() # dataframe
np.isnan(c)
np.isnan(b) # series
isnull()和notnull()
isnull()：缺失值返回True,正常值返回False
notnull():正常值返回True,缺失值返回False
b.isnull()
# 过滤非空
b[-b.isnull()]
b.notnull() # 同上, 选中所有非缺失值
b[b.notnull()]
# dataframe 使用isnull notnull的时候无法具体分清
c.isnull()
c[c.isnull()]
c.notnull()
c[c.notnull()]
结论：DataFrame不能通过布尔查询方式过滤缺失值,必须使用Pandas的特定方法过滤
查到缺失值后，Series可以直接过滤，DataFrame需要进一步处理(填充或删除)
去除缺失值
# series
b.dropna()
# 等同于上:查询所有非缺失值
b[b.notnull()]
# dataframe
c.dropna() # 默认按行
c.dropna(axis=1) # 按列删除
# 增加一列全部为缺失值的数据
c[3] = np.nan
# 行或列，有1个缺失值即删除
c.dropna(axis=1) # 简写，默认
c.dropna(axis=1, how='any')
# 行或列必须全部都是缺失值才删
c.dropna(axis=1, how='all')
c.dropna(thresh=3) # 行非缺失值数量大于等于3个，保留
填充缺失值
缺失值问题除了删除所在行列以外，还可以通过填充值解决
fillna()函数参数
c.loc[0, 1] = np.nan
c.loc[1:3,0] = np.nan
c.at[3,3] =100 #导致出现了第四行数据
c[3] = np.nan
c.fillna(method='ffill')
c.fillna(method='ffill',limit=3) # 设置填充改变的数量,limit=3每一列可以有三行数据改变
替换值
利用fillna方法填充缺失数据是值替换的一种特殊情况， replace方法用作替换值更简单、更灵活
data = pd.Series([1,-999,2,-999,-1000,3])
# 替换单值
data.replace(-999, np.nan)
# 替换多值， 多个值替换为1个
data.replace([-999, -1000], np.nan)
# 多个值替换为不同数值
data.replace([-999, -1000], [0, 1])
data.replace({-999: 0, -1000: 1})
#dataframe也是如此，直接替换值
c.replace(1,-1)
映射数据替换
map除了自定义函数运算，还是一种映射转换元素以及其他数据清理工作的便捷方式
a = pd.DataFrame([['鬃刷','皮带','煎蛋','观赏'],[10,20,30,40]]).T # 转置
y = {'鬃刷': '猪', '皮带': '牛', '观赏': '鱼', '衣服': '棉花'}
a[0].map(y)
移除重复数据
移除DataFrame的重复行
data = pd.DataFrame({'k1':['one'] * 3 + ['two'] * 4,'k2':[1,1,2,3,3,4,4]})
# 布尔型Series,各列重复值交集
data.duplicated()
# 重复行的移除
data.drop_duplicates()
data[-data.duplicated()]
# 移除自定义列重复行
data.drop_duplicates('k1') 或data.drop_duplicates(['k1']) （多个列可以在list中增加）
#keep : {‘first’, ‘last’, False},
# first默认留下第一次出现的值
data.drop_duplicates(['k1', 'k2'])
data.drop_duplicates(['k1', 'k2'], keep='first')
# last,留下最后一次出现的值
data.drop_duplicates(['k1', 'k2'], keep='last')
# 保留非全列的行数据时，结果行会不同
data.drop_duplicates(['k1'])
data.drop_duplicates(['k1'], keep='last')
# False,删掉所有重复值
data.drop_duplicates(['k1', 'k2'], keep=False)
移除重复索引值
obj = pd.Series(range(5), index = ['a','a','b','b','c'])
obj['a']
obj[obj.duplicated()]
obj[~(obj.index.duplicated())] # 查询不重复索引对应的值
检测和过滤异常值（了解）
过滤或变换异常值（outlier）在很大程度上就是运用数组运算
例子：一个含有正态分布数据的DataFrame
data = pd.DataFrame(np.random.randn(1000, 4))
data[0:3]
data[2][(data[2]>3) | (data[2]<-3)]
data[2][np.abs(data[2])>3]
# 找出全部绝对值大于3的值所在的行
data[np.abs(data)>3].dropna(how='all')
data[np.abs(data) > 3]
data[np.abs(data) > 3].any(axis=1) #前面的条件只要有一个生效就是true，一个没有就是False
data[data[np.abs(data) > 3].any(axis=1)]
a = np.array([3, -4, 7, -100])
np.sign(a) # 判断数据正负，正数1，负数-1，生成一个对应数据的1，-1数据
# 将数据范围限制在3到-3之间（大于3的改为3，小于-3的改为-3）
np.sign(data)
data[np.abs(data) > 3] = np.sign(data) * 3
697
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
