引入

 import pandas as pd

《《------------------------------------------------------------------------------------------------------》》

使用

Pandas 数据结构：一维数据结构   

创建字典格式 ：  pd.Series（{“今日销售量” ： 10086，“今日成交金额”：“1000084”}，time=‘2018.8.21’）    

创建数组格式 ： pd.Series([10086,1000084],index=['今日销售量','今日成交金额'],time='2018.8.21')

 

 《《------------------------------------------------------------------------------------------------------》》

 

Dataframe ：二维数据结构  是一个表格形的数据结构   ，“带标签的二维数组” ，带有（index） and （列标签）

使用 

data = {'name':['Jake','Jeek','Anmi'],'age':[22,15,32],'time':['2019.2.1','2019.3.1','2019.4.2']}

pd.DataFrame(data)   形成一个表格数据

创建的三种方法   ：其他方法都不通用

1.data = {'name':['a','b','c'],'age':[22,15,32],'time':['2019.2.1','2019.3.1','2019.4.2']}

2. 第二种  设置两个一维数组  Series的方式

      data={'one':pd.Series(np.random.rand(2)),'two':pd.Series（np.random.rand(3)）}    不设置index的

      data={'one':pd.Series(np.random.rand(2)),'two':pd.Series（np.random.rand(3)）,index=['a','b','c']}    设置 index的

3.   第三种  通过二维数组，指定index 和 colums

arr=np.arange(9).reshape(3,3)

      data = pd.DataFrame(arr)

      data = pd.DataFrame(data,index=['a','b','c'],colums=['昨天'，‘今天’，‘明天’])

      print(data)    

 

重新指定cloums列名：  pd.DataFrame(data,colums=['H5','Json','Dic'])  

出现问题：

？如果指定后，列名比数据多，那么该列下面的数据  显示 NaN  

？如果指定后，列名少于数据，只会显示对应的列数据 

《《------------------------------------------------------------------------------------------------------》》

Pandas 索引+切片     中筛选数据

Series和Datafram索引的原理一样，我们以Dataframe的索引为主来学习

  • 列索引：df['列名'] （Series不存在列索引）
  • 行索引：df.loc[]、df.iloc[]

选择列 / 选择行 / 切片 / 布尔判断

     data['one','abc']      通过columns 选

     data.loc['a','b','c','d','e']   通过行   选       这个里面切片是包含最后一个的

     data.iloc[:3]            通过切片 用数字表示，3之前的行  不包含3

     data[data>50]     数据大于50的值

     data[data['a'] > 50]    a列  》 50   行数据

    ？选择出来后 按照 顺序放入 序列

     data[data > 5].index().tolist()   转为数组 按照顺序 

《《------------------------------------------------------------------------------------------------------》》

Pandas 基本技巧 

df.head()   默认前5条数据，也可以在括号内指定数字       

df.tail()    默认后5条数据

df.T()    转置    index  互换  columns | 列变行，行变列

添加和修改   删除数据行

   （添加操作）

       这个二维数据表格  index 只有 5，那么就把  index[6]  赋值

   （修改操作）

       df['a']  = 200   df['a'][0] = 333  

   （删除操作）

     del df['a']    删除 columns  【a】

     df.drop(0)  删除行  删除index  行 

两个数据对齐合并  相加

    就会 默认 对应行和列  对齐相加填充，如果没有的行和列，填充NaN 

DataFrame  数据排序  

      random4 = np.random.rand(3,3)*100
      print(random4)
           data4 = pd.DataFrame(random4,columns=['a','b','c'])
           data5 = data4.sort_values(['b'],ascending = True) #升序     False #降序   
           data5

 DataFrame  索引排序

       data7.sort_index()   #升序

       data7.sort_index(inplace=True) #数据更新改变  

《《------------------------------------------------------------------------------------------------------》》

DataFrame  数据计算和统计基础

   # np.nan ：空值
   # .mean()计算均值

            m2 = df.mean(axis=1)    1=行数值计算结果    0 = 列结果

              # axis参数：默认为0，以列来计算，axis=1，以行来计算，这里就按照行来汇总了
   # 只统计数字列   

               m3 = df.mean(skipna=False)

               # skipna参数：是否忽略NaN，默认True，如False，有NaN的列统计结果仍未NaN
   # 可以通过索引单独统计一列

# 主要数学计算方法，可用于Series和DataFrame（1）


df = pd.DataFrame({'key1':np.arange(10),

                  'key2':np.random.rand(10)*10})

print(df)

print('-----')


print(df.count(),'→ count统计非Na值的数量\n')

print(df.min(),'→ min统计最小值\n',df['key2'].max(),'→ max统计最大值\n')

print(df.quantile(q=0.75),'→ quantile统计分位数，参数q确定位置\n')

print(df.sum(),'→ sum求和\n')

print(df.mean(),'→ mean求平均值\n')

print(df.median(),'→ median求算数中位数，50%分位数\n')

print(df.std(),'\n',df.var(),'→ std,var分别求标准差，方差\n')

print(df.skew(),'→ skew样本的偏度\n')

print(df.kurt(),'→ kurt样本的峰度\n')

# 主要数学计算方法，可用于Series和DataFrame（2）

    df['key1'].cumsum()    单列的累计和 

    df['key1'].cumprod()   单列累计积 

    print(df.cummax(),'\n',df.cummin(),'→ cummax,cummin分别求累计最大值，累计最小值\n')

 # 唯一值：.unique()

    解决问题：colums 中有重复的值，两个一样的列，那么取到唯一 个      重新整理成为一个DataFrame表格

## 值计数：.value_counts()

    解决问题: 得到该数据  出现的频率次数   a:2    b  3    生成一个新的 Series    括号内可写排序：sort = False   or  True

# 成员资格：.isin()

    解决问题： 一个DataFrame 显示数据，我就想知道 里面有没有我指定的一个 50    有就是对应位置显示 True，没有就是False

《《------------------------------------------------------------------------------------------------------》》

   pandas 文本数据处理

      一般处理 ：

1.自动排除为np的值   NaN  

2.查看指定  文本数据字符的个数     .str.count()

3.修改大小写    .str.upper()   .str.lower() 

4.字符长度  .str.leng()  

5.开始字符是哪一个   .str.startwith('')

6.结束字符是哪一个  .str.endwith('')  

print(s.str.lower(),'→ lower小写\n')
print(s.str.upper(),'→ upper大写\n')
print(s.str.len(),'→ len字符长度\n')
print(s.str.startswith('b'),'→ 判断起始是否为a\n')
print(s.str.endswith('3'),'→ 判断结束是否为3\n')

df.columns.str.upper()   修改数据列

去空格
print(s.str.strip())  # 去除字符串中的空格
print(s.str.lstrip())  # 去除字符串中的左空格
print(s.str.rstrip())  # 去除字符串中的右空格

替换字符中的空格  

str.replace(' ',''，n=1)     把空格替换为  空字符    

不写第三个参数 ，那么就是 全部替换 ，写了就是指定替换几个

 

# 字符串常用方法（4） - split、rsplit

print(s.str.split(',').str[0])
print(s.str.split(',').str.get(1))

# 可以使用get或[]符号访问拆分列表中的元素

# 可以使用expand可以轻松扩展此操作以返回DataFrame
# n参数限制分割数
# rsplit类似于split，反向工作，即从字符串的末尾到字符串的开头
print(s.str.split(',', expand=True))
print(s.str.split(',', expand=True, n = 1))
print(s.str.rsplit(',', expand=True, n = 1))

 

# 字符串索引

print(s.str[0])  # 取第一个字符串
print(s.str[:2])  # 取前两个字符串
print(df['key2'].str[0])
# str之后和字符串本身索引方式相同

DataFrame 合并

     .merge（data1,data2,on='key'）   根据key列为索引合并，看下两个是否共有  一样的key ，有就保留

   @合并有有一个 分类 ：  交集  和  并集      how='' /inner、outer   、left、right

        交集：解释就是 原有的数据合并没有对应上，那么就会不要，只保留 共有的

        并集：解释就是  合并后不管你有没有，都会保留，只不过有的就是 保留原有数据，没有的 NaN 

   然后就是  设置参考键： on=‘’    设置根据on里面的值，两两对比，如果一样就合并   

   on是一个键，how='left'    根据两个表，用第一个表         how='right'   根据两个表 ，用第二个表 

   指定参考键：我想用左边的lkey列作为左边的参考键，  我想用右边表的index 作为  参考键   （两个数据表合并比较）

         （left_index   right_index  左边（设置True就行） left_on   right_on  这俩on（还是制定 index只不过分开指定，左表，右表说法） ）     

代码展示

dataG = pd.DataFrame({'key':list('abcdedf'),'list':range(7)});
dataW = pd.DataFrame({'key':list('abcdedf'),'list':range(3,10)});
print(pd.merge(dataG,dataW,on=['list'],how='outer'))

how ='outer'  根据list为合并的条件，用了outer  没有达到要求的NaN补全

print(pd.merge(df1, df2, left_on='key', right_index=True))

左边的指定键  为key，右边的表用 角标index 为键   合并比较

 数据连接

     两个DataFrame  连接，通过pd.concat([数组表1，数组表2]).sort_index()    角标顺序排列连接  

     两个DataFrame  连接，通过  pd.concat([数组表1，数组表2])，axis=1   列+列 成为一个DataFrame ，空的位置 用 NaN补全

inplace  

     两个Series   pd.reset_index(inplace=True).drop = True      

    一个Series一维，重置了他的index值，0 1 2 3 4 5 6   然后吧替换之前的index 设置为一个列，drop 设置True 就是问你是否删除这个之前的；列

去重

    按照 s.duplicate()     就会出现一个  True  False 的列表 ，  打印出  s[s.s.duplicate()    == False]   False  就代表不重复的值 

replace

      replace('a','w')   replace(['a','b'],50)    都可以进行一个替换  

 

 DataFrame 数据分组（简称列分组）

     根据数据列columns名字，分组，并计算处理，得出数据   求和、平均值、长度、常用的一些列计算   

        简单解释语句：

               df.groupby('A')    通过A列，里面的数据 只要不一样就会成组，  分成一个组然后 计算 

               df.groupby(['A','B']).mean()    通过A/B两列，里面的数据，只要A 和 B两个组成不同的配对，就可以成组，计算

               df.groupby(['A'])['D'].mean()  # 以A分组，算D的平均值

       分组后 类型格式为  groupby类型， 经过处理后 得出 可迭代对象，可以是数组、元祖、字典    一一对应操作方法

              print(list(df.groupby('X')), '→ 可迭代对象，直接生成list\n')
              print(list(df.groupby('X'))[0], '→ 以元祖形式显示\n')
             for n,g in df.groupby('X'):
                 print(n)
                 print(g)
             print('###')     # n是组名，g是分组后的Dataframe

    # .get_group()提取分组后的组

              print(df.groupby(['X']).get_group('A'),'\n')

    # .groups：将分组后的groups转为dict
    # 可以字典索引方法来查看groups里的元素

              grouped = df.groupby(['X'])
              print(grouped.groups)
              print(grouped.groups['A'])  # 也可写：df.groupby('X').groups['A']

     # .size()：查看分组后的长度

              grouped.size()

# 按照两个列进行分组

     grouped = df.groupby(['A','B']).groups
           print(df)
           print(grouped)
           print(grouped[('foo', 'three')])

# 分组计算函数方法


s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])

grouped = s.groupby(level=0)  # 唯一索引用.groupby(level=0)，将同一个index的分为一组

print(grouped)

print(grouped.first(),'→ first：非NaN的第一个值\n')

print(grouped.last(),'→ last：非NaN的最后一个值\n')

print(grouped.sum(),'→ sum：非NaN的和\n')

print(grouped.mean(),'→ mean：非NaN的平均值\n')

print(grouped.median(),'→ median：非NaN的算术中位数\n')

print(grouped.count(),'→ count：非NaN的值\n')

print(grouped.min(),'→ min、max：非NaN的最小值、最大值\n')

print(grouped.std(),'→ std，var：非NaN的标准差和方差\n')

print(grouped.prod(),'→ prod：非NaN的积\n')

 

DataFrame 读取分组

      import os       引入 修改默认引入路径
       os.chdir('c:/zzz/www')

     导入普通文本文件类型

   

  pd.read_table('data1.txt',delimiter=',',sep=False)     

 

     导入Excel数据表格  少量数据

   

dataexcel = pd.read_excel('地市级党委书记数据库（2000-10）.xlsx',sheet_name='地市级党委书记数据库（2000-10）',header=0)

       print(dataexcel.head())

 

     导入CSV大型数据表格

  

   datacsv = pd.read_csv('地市级党委书记数据库（2000-10）.csv',encoding = 'utf-8')

      print(datacsv.head())