1. pandas简介

Pandas是基于Numpy的数据分析包,内核是Numpy.
加粗样式 Pandas通常是用于数据分析过程中, 数据的清洗, 数据预处理, 数据的描述性分析等过程中.
在整个Python数据分析的生态环境中, Pandas的地位非常重要, 利用Pandas可以快速便捷的对数据进行各种各样的处理与操作.
Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）.
在Pandas中, 最重要的两种数据结构是1维的Series和2维的DataFrame.
Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近.
Series中能保存不同种数据类型，字符串、boolean值、数字等都能保存在Series中。但是每个Series中只能保存一种数据结构.
DataFrame：二维的表格型数据结构.有多个Series共同构成的集合就变成DataFrame.

2. Series

Series 是一个带有名称和索引的一维数组，既然是数组，肯定要说到的就是数组中的元素类型，
在Series中包含的数据类型可以是整数、浮点、字符串、Python对象等

2.1 Series创建

pandas.Series(data,index,dtype,name,)

data: 数据来源,可为数组,字典,可迭代类型和标量值
index: 索引值
dtype: 数据类型
name: 值列名称

2.2 Series常用属性

1、s.name #提取名称,可以直接赋值,修改原数据
2、s.index # 提取索引,可以赋值,修改原数据,但数量要相等
3、s.values # 提取值,不可直接赋值
4、s.dtype # 提取数据类型,使用astype函数修改
5、s.index.name # 索引名称,可以直接赋值,直接修改原数据

2.3 Serices索引和切片

1.按照字典方式索引: Serices[‘索引值’] 或Serices.get(‘索引值’,default)
2. 按照字典方式索引: 和列表索引和ndarray索引方式共通
3. 传入索引值的方式提取数据

2.4Serices删除数据

1、Serices.drop() : 删除数据返回副本,不会修改原数据
2、Serices.pop() : 将数据在原数据中直接弹出返回,将原数据直接修改

3.DataFrame

3.1DataFrame创建

1、构建DataFrame主要有两种思路:
1.1. 字典的方式创建: 以列的方式进行组织,key作为列名,值作为列值
1.2. Serices方式创建: 以行的方式组织,一个Serices代表一列,列名需要参数传递进去
2、本地读取数据: DataFrame = pandas.read_(path)
3、保存数据至本地: DataFrame.to_(path)
#Dataframe创建
pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
data：numpy ndarray(结构化或同类)，dict或DataFrame，Dict可以包含Series，数组，常量或类似列表的对象
index：dataframe的索引，如果没有自定义，则默认为RangeIndex(0,1,2，…，n)
columns：dataframe的列标签，如果没有自定义，则默认为RangeIndex(0,1,2，…，n)
dtype：默认None，要强制的数据类型。 只允许一个dtype
copy：boolean，默认为False 

#实例
# 从np.array 转换为 pd.DataFrame
data = np.array([['','Col1','Col2'],
                ['Row1',1,2],
                ['Row2',3,4]])
 
pd.DataFrame(data=data[1:,1:],
             index=data[1:,0],
             columns=data[0,1:])
 
#      Col1 Col2
# Row1    1    2
# Row2    3    4
 
# 直接采用字典做参数
my_dict = {1: ['1', '3'], 2: ['1', '2'], 3: ['2', '4']}
print(pd.DataFrame(my_dict))
#    1  2  3
# 0  1  1  2
# 1  3  2  4
 
# 用一个DataFrame做输入参数
my_df = pd.DataFrame(data=[4,5,6,7], index=range(0,4), columns=['A'])
print(pd.DataFrame(my_df))
#    A
# 0  4
# 1  5
# 2  6
# 3  7
 
# 输入一个Series
my_series = pd.Series({"United Kingdom":"London", "India":"New Delhi", "United States":"Washington", "Belgium":"Brussels"})
print(pd.DataFrame(my_series))
#                          0
# Belgium           Brussels
# India            New Delhi
# United Kingdom      London
# United States   Washington

#或者
#方式一
a = pd.DataFrame(np.arange(10).reshape(2,5))
print(a)

#方式二
a = pd.DataFrame(np.arange(10).reshape(2,5),index=list("ab"),columns=list("qwxyz"))
print(a)

#方式三
temp_dict = {"name":["yangwj","ywj"],"age":[28,29],"tel":["10080","10010"]}
a = pd.DataFrame(temp_dict)
print(a)

d={'one':{'a':1,'b':2,'c':3},'two':{'a':4,'b':5,'c':6},'three':{'a':7,'b':8,'c':9}}
df=pd.DataFrame(d)

3.2 DataFrame索引和切片

Series只有行索引，而DataFrame对象既有行索引，也有列索引
行索引，表明不同行，横向索引，叫index，0轴，axis=0
列索引，表明不同列，纵向索引，叫columns，1轴，axis=1

1、提取列数据
1.1 提取列数据的方式和Serices方式相同,分为显示索引和隐式索引两种
2、提取行数据
2.1 提取行数据需要使用函数:
2.1.1 显示索引: DataFrame.loc[行值,列值] 注意,loc函数是中括号,不是小括号
2.1.2 隐式索引: DataFrame.iloc[行索引,列索引] 同样iloc函数也是中括号

a)常规获取
# 方括号写数组，表示取行，对行进行操作
　　# 写字符串，表示取列索引，对列进行操作
　　print(a[:3]) #取前3行
　　print(a["Row_Labels"])#取列

b)通过loc和iloc获取
　　#df.loc 通过标签索引行或列数据
　　#df.iloc通过位置获取行数据 iloc --> index location
　　a = pd.DataFrame(np.arange(12).reshape(3,4),index=list("abc"),columns=list("wxyz"))
　　print(a)

　　print(a.loc["a",:]) #取一行
　　print(a.loc[["a","c"],:])#取多行
　　print(a.loc[:,["x","y"]])#取多列


　　print(a.iloc[1,:])#取行
　　print(a.iloc[:,1])#取列
　　print(a.iloc[[1,2],[2,3]])#取多行多列

c)布尔索引获取,可以通过&或者|做多条件布尔获取
　　g = g[g["Count_AnimalName"]>800]
　　print(g)
　　print(g[(g["Count_AnimalName"]>800) & (g["Count_AnimalName"]<1000) ])
　　#通过字符串长度进行选取
　　print(g[(g["Row_Labels"].str.len()>4) & (g["Count_AnimalName"]<1000) ])

3.3DataFrame新增(修改)和删除行或列

1、对行操作:
1.1 新增: DataFrame.loc[行索引值] = [值序列] 值的个数要符合DataFrame结构,若行值存在,则修改原数据
1.2 删除: 使用drop函数或pop函数
2、对列操作:
2.1 新增: DataFrame[列索引值] = [值序列] 值的个数要符合DataFrame结构,若行值存在,则修改原数据
2.2. 删除: 使用drop函数或pop函数
#(1)创建DataFrame
import pandas as pd
d={'one':{'a':1,'b':2,'c':3},'two':{'a':4,'b':5,'c':6},'three':{'a':7,'b':8,'c':9}}
df=pd.DataFrame(d)
print(df)
'''one two three
a 1 4 7
b 2 5 8
c 3 6 9'''
#(2)在dataframe中增加一列
df['four']=[10,11,12]
print(df)
'''one two three four
a 1 4 7 10
b 2 5 8 11
c 3 6 9 12'''
#(3)在dataframe中增加一行
df.loc['d']=[2,4,6,8]
print(df)
'''
one two three four
a 1 4 7 13
b 2 5 8 14
c 3 6 9 15
d 2 4 6 8'''
#(4)在dataframe中删除特定的列
df=df.drop(columns='four')#或者写为：df.drop(columns='four',inplace=True)
#或者del df['four']
print(df)
#(5)在dataframe中插入特定的列
df.insert(0,'zero',[10,11,12])
#df.insert(添加列位置索引序号，添加列名，数值)
print(df)
#(6)在dataframe中插入特定的行
'''在dataframe中特定的位置插入一行是没有什么好的方法的。不过倒是可以通过别的方法间接得到:
首先加入想要加入的行，然后增加一列，设计好该列中每一行应该对应的值，然后按照该列对所有的行进行排序，排序之后，再把该列删掉即可。
例如我要在第一行，第二行之间插入一行，行名为“line”,值为[2,4,6,8]。可以这么做：'''
df.loc['line']=[2,4,6,8]
df['change']=[1,3,4,2]
df=df.sort_values(by='change')
df.drop(columns='change',inplace=True)
print(df)
'''zero one two three
a 10 1 4 7
line 2 4 6 8
b 11 2 5 8
c 12 3 6 9'''
#(7)在dataframe中插入行
df.append(row,ignore_index=True)

3.4DataFrame常用函数和属性

1.查看整体基本信息: DataFrame.info() 返回各列的类型
2.查看前几行数据: DataFrame.head(n) 返回表的前n条数据,不写默认为5条
3.查看后几行数据:DataFrame.tail(n) 返回表的最后n条数据,不写默认为5条
4.转置: DataFrame.T 转换行列
5.查看表形状: DataFrame.shape
6.获取数据的原有信息: DataFrame.values

a)基础属性
    df.shape  #行数、列数
    df.dtype #列数据类型
    df.ndim #数据维度
    df.index #行索引
    df.columns #列索引
    df.values #对象值，二维ndarray数组

b)整体情况查询
    df.head(3) #显示头部几行，默认5行
    df.tail(3) #显示末尾几行，默认5行
    df.info() #相关信息概览：行数、列数、索引、列非空值个数、列类型、内存占用
    df.describe() #快速综合统计结果： 计数、均值、标准差、最大值、四分位数、最小值等

3.5 DataFrame使用掩码提取数据

提取方式和切片一样,但是判断条件需要使用单行列或行值进行判断,
无法直接使用DataFrame作为判断条件

3.6描述与统计

1.基本统计值函数: DataFrame.describe() : 返回一个DataFrame,默认返回计数,平均值,标准差,最小值,最大值,四分位数
2.统计某列值出现次数: DataFrame[列名].value_counts(): 返回每列中不同值出现次数
3.离散化:将数值列划分为及格区间:
3.1. 等宽分箱: Pandas.cut(DataFrame.[‘列名’] , 分箱个数,labels = ) : 按照同等宽度划分区间,labels参数可以给个区间命名
3.2. 等深分箱: Pandas.p.cut(DataFrame.[‘列名’] , 分箱个数) : 按照数值划分区间, 实现每个区间内的值个数接近
4.排序:
4.1. 按照索引方式排序: DataFrame.sort_index() : 按照索引排序,可是指定axis参数选择轴
4.2. 按照列值方式排序: DataFrame.sort_values(by = ): 按照 by指定的列中的值排序
5.根据现有列生成新列: DataFrame.assign(**kwargs) : 可变长指定列名参数: 列名 = 对表中某一列执行操作
6.修改索引: DataFrame.rename(index = ,columns = ): 使用index参数修改行索引,使用columns修改列索引,参数值可以是字典或函数,一般使用字典的方式
7.修改类型: DataFrame[‘列名’].astype(‘类型’): 修改类型,返回一个副本

3.7万能函数: map,apply,applymap

1.map函数: DataFrame[‘列名’].map(自定义函数): 将列的每一个元素传入函数中,
返回一个Series,map函数是一个Serices函数
#map()用法
'''>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]'''
df1.sales1.map(lambda x : 1 if x>0 else 0)
#当我们要对数据框（DataFrame）的数据进行按行或按列操作时用apply()
2.apply函数: apply函数支持DataFrame和Serices两种类型,可以对列操作,
也可以对DataFrame操作,操作方式和map一样,apply操作方式是以一列为以一个单位传入参数
df1.apply(lambda x :x.max()-x.min(),axis=1)
#当我们要对数据框（DataFrame）的每一个数据进行操作时用applymap()，返回结果是DataFrame格式
3.applymap函数:applymap函数只能用在DataFrame上,apply操作方式是以DataFrame中的每一个元素为一个单位传入参数中
df1.applymap(lambda x : 1 if x>0 else 0)

3.8 DataFrame的合并

1.DataFrame.append函数: DataFrame.append(DataFrame2) : 将1和2合并,相同列名追加,不同列名作为新的列,另一个表中的此列值为NAN
2.Pandas.concat函数: Pandas.concat(): 第一个参数为DataFrame组成的列表,可以使用join参数指定内连接还是外连接,默认外连接,可以使用axis参数指定轴,默认按照列合并
3.Pandas.merge函数: Pandas.merge(left,right,how,on,left_on,right_on): merge又称为数据库连接,功能和数据库中的连接类似,left和right参数代表左表和右表,how代表连接方式(left,right,inner,outer),on 指定两个表连接的关系列,若两表不同,使用left_on和right_on参数
'''参数含义：
1:left、right DataFrame或命名为Series
需要合并的DataFrame
2:how {‘left’，‘right’，‘outer’，‘inner’}，默认’inner’
left：仅使用左DataFrame中的键，类似于SQL左外连接; 保留关键顺序。
right：仅使用右DataFrame中的键，类似于SQL右外连接; 保留关键顺序。
outer：使用来自两个DataFrame的键的并集，类似于SQL全外连接; 按字典顺序排序键。
inner：使用两个DataFrame的键交集，类似于SQL内连接; 保留左键的顺序。
3:on 标签或列表
以一列的字段作为合并基准唯一值
4:left_on、right_on 标签或列表，或类似数组
在左侧/右侧连接的列或者索引
5:left_index、right_index 标签或列表，或类似数组
以左侧或者右侧索引作为连接
6:sort bool，默认为False
在结果DataFrame中按字典顺序对连接键进行排序。如果为False，则连接键的顺序取决于连接类型（关键字 如何）
7:suffixes （str，str）的元组，默认（‘x’，’ y’）
合并后的DataFrame重复列名会加上_x’，’ y’后缀
'''

3.9 缺失值处理

1.isnull函数和notnull函数: DataFrame.isnull() 返回一个全是Bool值的DataFrame
2.dropna函数:丢弃空值列,DataFrame.dropna(axis,how,thresh,subset,inplace):
2.1. axis: 指定轴
2.2. how: 删除规则:any整行有一个空值就删除,all全部为空才删除
2.3. thresh: thresh = n,一行或一列中至少有n个非空值,才会保留,否则删除行或列
2.4. subset: 选择处理的行索引或列索引
2.5. inplace:是否直接在原地修改,默认为False返回副本,如果为True则直接修改原数据,不会有返回值

3.10 填充缺失值:

1.fillna函数
1.1. 固定值填充: DataFrame.列名.fillna(n): n为要填充的值,会将所有的空值都填为n
1.2. 上下文填充: method参数可以选择空值上面的数值或下面的数值进行填充:
     1.2.1. method = ‘pad’ 或method= ‘ffill’ 可以选择空值上面的一个有效值进行填充
    1.2.2. method = ‘backfill’ 或者method = ‘bfill’ 可以选择空值下面的一个2.有效值进行填充
2.interpolate函数: 默认使用线性差值进行填充,可以通过过method参数设置方式
替换缺失值: replace函数

3.11 处理文本数据

1.Serices.str属性,方便对Serices中的每个字符串元素进行操作
2.支Python原生字符串方法: len ,lower ,upper ,islower ,isupper ,find ,count ,strip ,split
3.高级方法: contains,startswith,endswith,replace
3.1. contains函数: 判断字符串是否包含某个子字符串,返回一个bool Serices
3.2. startswith函数,判断字符串的开头是否是某个子字符串
3.3. endswith函数,判断字符串是否以某个子字符串结尾
3.4. str.replace和replace的区别: str.replace是对字符串中的某个子字符串进行替换, python原生replace需要对整个字符串进行替换,不能替换字符串局部
4.cat函数,连接字符串: 将整列的数据连接在一起,形成一个大字符串,可以使用sep参数设置分隔符
5.get_dummies()函数: 生成哑变量,可以指定sep参数,设置原字符串中的分隔符,根据整列值生成新的列,有多少不重复值,就生成多少个列,原列值和列名相等则列值为1,否则为0,返回一个DataFrame

3.12 数据分组_groupby

1.根据筛选列,和筛选条件,将数据分组
2.DataFrame.groupby(‘列名’) : 会返回一个DataFrameGroupby对象,内部放了分组数据,但无法显示,需要进一步设置累计函数后才会显示结果
3.筛选表:DataFrame.groupby(‘列名’).累计函数() 返回分组后,表中所有列的累计函数值
4.筛选列: DataFrame.groupby(‘列名’)[‘要筛选的列名’].累计函数() ,返回一个Data