link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

二-1 . series特性

1 . series 的索引

可以使用中括号取单个索引(此时返回的是元素类型 ) , 或者中括号里一个列表取多个索引(此时返回的是一个 Series类型 ) .

(1) . 显示索引 :

- 使用 index 中的元素作为索引值

- 使用 s.loc [ ] (推荐) , 注意 : loc 中括号中放置的一定是显示索引

注意 : 此时是闭区间

(2) . 隐式索引 :

- 使用整数作为索引值

- 使用 .iloc [ ] (推荐) : iloc 中的括号中必须要放置隐式索引

注意 : 此时是半开区间

2 . 切片

(1) . 显示索引切片 : index 和 loc

(2) . 隐式索引切片 : 整数索引值和 iloc

3 . 基本概念

可以把series看成是一个定长的有序字典

(1) . 向Series增加一行 , 相当于给字典增加一组键值对. 可以通过 shape , size , index , values 等得到 series的属性 .

(2) . 可以使用 .head() 和 .tail 分别查看前n个和后n个值

4 . 去重

.unique()

二-2 . Series数据对齐

1 . pandas在运算时,会按索引进行对齐然后运算,如果存在不同的索引,则结果的索引是两个操作索引的并集.

2 . series 之间的运算

1) . + - * /

2) . add() , sub() , mul() , div() ,

注意 : 如何在两个Series对象相加时将缺失值设为0？

    　　　　　　sr1.add(sr2, fill_value=0)

3) . 在运算中自动对齐不同索引的数据 , 如果索引对不齐,则补NaN

二-3 . Series数据缺失

当索引没有对应值的时候,可能会出现缺失数据显示NaN的情况

1、缺失数据：使用NaN（Not a Number）来表示缺失数据。其值等于np.nan。内置的None值也会被当做NaN处理。

2、处理缺失数据的相关方法：

dropna() 过滤掉值为NaN的行

fillna() 填充缺失数据

isnull() 返回布尔数组，缺失值对应为True

notnull() 返回布尔数组，缺失值对应为False

3、过滤缺失数据：sr.dropna() 或 sr[data.notnull()]

4、填充缺失数据：fillna(0)

三 . DataFrame

DataFrame是一个表格型的数据结构.

DataFrame由一定顺序排列的多列数据组成
DataFrame既有行索引,也有列索引

行索引：index

列索引：columns

值：values

三-1 . DataFrame的创建

导包 : from pandas import DataFrame

最常用的方法是传递一个字典来创建。DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。

此外，DataFrame会自动加上每一行的索引。

使用字典创建的DataFrame后，则columns参数将不可被使用。

同Series一样，若传入的列与字典的键不匹配，则相应的值为NaN。

1 . 使用 ndarray 创建DataFrame

2 . 使用字典创建 DataFrame

三-2 . DataFrame查看数据

查看数据常用属性及方法：
        index                    获取索引
        T                        转置
        columns                    获取列索引
        values                    获取值数组
        describe()                获取快速统计
    DataFrame各列name属性：列名
    rename(columns={})     #字典创建不能用

三-3 . DataFrame的索引与切片

DataFrame有行索引和列索引。
DataFrame同样可以通过标签和位置两种方法进行索引和切片。

DataFrame使用索引切片：

方法1：两个中括号，先取列再取行。 df['A'][0]

方法2（推荐）：使用loc/iloc属性，一个中括号，逗号隔开，先取行再取列。

loc属性：解释为标签
iloc属性：解释为下标
向DataFrame对象中写入值时只使用方法2
行/列索引部分可以是常规索引、切片、布尔值索引、花式索引任意搭配。（注意：两部分都是花式索引时结果可能与预料的不同）

1 . DataFrame的索引

(1) . 对列进行索引

(2) . 对行进行索引

- 使用 .loc [] 加index来进行索引

- 使用 .iloc [] 加整数来进行索引

同样返回一个 Series , index为原来的 columns

(3) . 对元素进行索引

- 使用列索引

- 使用行索引 (iloc[3,1] or loc['C','q']) 行索引在前，列索引在后

2 . 切片

注意 : 直接使用中括号时 :

- 索引表示列索引

- 切片表示行切片

三-4 . DataFrame的运算

DataFrame之间的运算同Series一样

- 在运算中自动对齐不同索引的数据

- 如果索引不对应,则补NaN

三-5 . DataFrame的数据对齐和数据缺失

DataFrame对象在运算时，同样会进行数据对齐，行索引与列索引分别对齐。
结果的行索引与列索引分别为两个操作数的行索引与列索引的并集。

- None

None是Python自带的，其类型为python object。因此，None不能参与到任何计算中。

- np.nan (NaN)

np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。

pandas中None与np.nan都视作np.nan

DataFrame处理缺失数据的相关方法：

dropna(axis=0,where=‘any’,…) 过滤掉值为NaN的行

注意 : 在dropna中, axis=0 表示行,与常规相反

最常见的方法是给DataFrame构造函数的index或者columns参数传递两个或更多的数组

DataFrame(data=np.random.randint(0,100,size=(2,2)),columns=[['a','b'],['A','B']])

2 . 显示构造

pd.MultiIndex.from_product

col=pd.MultiIndex.from_product([['qizhong','qimo'],
                                ['chinese','math']])
#创建DF对象
df = DataFrame(data=np.random.randint(60,120,size=(2,4)),index=['tom','jay'],
         columns=col)

3 . 多层行索引

df['qimo']

df['qimo']['math']

# 获取tom期中所有科目的考试成绩
df['qizhong'].loc['tom']

注意
　　在对行索引的时候，若一级行索引还有多个，对二级行索引会遇到问题！也就是说，无法直接对二级索引进行索引，必须让
二级索引变成一级索引后才能对其进行索引！

访问一列或多列直接用中括号[columnname] [[columname1,columnname2...]] 访问一行或多行 .loc[indexname] 访问某一个元素 .loc[indexname,columnname] 获取李四期中的php成绩行切片 .[index1:index2] 获取张三李四的期中成绩列切片 .loc[:,column1:column2] 获取张三李四期中的php和c++成绩

三-7 . 聚合操作

所谓的聚合操作：平均数，方差，最大值，最小值…

df.sum(axis=0)
df.mean()

三-8 . pandas的拼接操作

pandas的拼接分为两种：

级联：pd.concat, pd.append

合并：pd.merge, pd.join

1 . 使用pd.concat()级联

pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数：

axis= 0 join = ' outer ' / ' inner ' :表示的是级联的方式，outer会将所有的项进行级联（忽略匹配和不匹配），　　　　　　　　　　　而inner只会将匹配的项级联到一起，不匹配的不级联 ignore_index =False

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

(1) . 匹配级联

df1 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','b','c'],columns=['A','B','C'])
df2 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','d','c'],columns=['A','d','C'])

(2) . 不匹配级联

不匹配指的是级联的维度索引不一致.例如 : 纵向级联时索引不一致,横向级联时索引不一致

连接方式 :

df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                'group':['Accounting','Engineering','Engineering'],
df2 = DataFrame({'employee':['Lisa','Bob','Jake'],
                'hire_date':[2004,2008,2012],
pd.merge(df1,df2) #自动找相同的,列进行合并

(2) . 多对一合并

df3 = DataFrame({
    'employee':['Lisa','Jake'],
    'group':['Accounting','Engineering'],
    'hire_date':[2004,2016]})
df4 = DataFrame({'group':['Accounting','Engineering','Engineering'],
                       'supervisor':['Carly','Guido','Steve']
pd.merge(df3,df4,how='outer')

left right

(3) . 多对多合并

df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                 'group':['Accounting','Engineering','Engineering']})
df5 = DataFrame({'group':['Engineering','Engineering','HR'],
                'supervisor':['Carly','Guido','Steve']
pd.merge(df1,df5,how='left')

left right

(4) . key 的规范化

当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名

df1 = DataFrame({'employee':['Jack',"Summer","Steve"],
                 'group':['Accounting','Finance','Marketing']})
df2 = DataFrame({'employee':['Jack','Bob',"Jake"],
                 'hire_date':[2003,2009,2012],
                'group':['Accounting','sell','ceo']})
pd.merge(df1,df2,on='group',how='outer')

df1 = DataFrame({'employee':['Bobs','Linda','Bill'],
                'group':['Accounting','Product','Marketing'],
               'hire_date':[1998,2017,2018]})
df5 = DataFrame({'name':['Lisa','Bobs','Bill'],
                'hire_dates':[1998,2016,2007]})
display(df1,df5)

(5) . 内合并与外合并 : out取并集 , inner取交集

内合并 : 只保留两者都有的key(默认模式)

df6 = DataFrame({'name':['Peter','Paul','Mary'],
               'food':['fish','beans','bread']}
df7 = DataFrame({'name':['Mary','Joseph'],
                'drink':['wine','beer']})
display(df6,df7)

df6 = DataFrame({'name':['Peter','Paul','Mary'],
               'food':['fish','beans','bread']}
df7 = DataFrame({'name':['Mary','Joseph'],
                'drink':['wine','beer']})
display(df6,df7)
pd.merge()

三-9 . 数据处理

1 . 删除重复元素 : duplicated()

使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True

- keep 参数 : 指定保留那一重复的行数据

# 创建具有重复元素行的DataFrame
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
# 创建一个 df
np.random.seed(1)
df = DataFrame(data=np.random.randint(0,100,size=(8,6)))
#手动将df的某几行设置成相同的内容
df.iloc[1] = [6,6,6,6,6,6]
df.iloc[3] = [6,6,6,6,6,6]
df.iloc[4] = [6,6,6,6,6,6]
 未变之前                                                          改变之后
   (1) . 方式一 : 
# 使用duplicated查看所有重复元素行
df.duplicated(keep='last') 
indexs = df[df.duplicated(keep='last')].index #获取需要删除行的索引
df.drop(labels=indexs,axis=0) #删除重复行
  (2) . 方式二 : 
使用drop_duplicates()函数删除重复的行
drop_duplicates(keep='first/last'/False)
df.drop_duplicates() #一步到位
2 . 映射 
 (1) . replace() 函数 : 替换元素
　　使用replace()函数，对values进行映射操作
注意：DataFrame中，无法使用method和limit参数
df.replace(to_replace=6,value='six') #用'six'代替df中的'6'
df.replace(to_replace={3:6},value='six') #用'six'代替df中第4列的'6'
df.replace(to_replace={1:'one'}) #用'one'代替df中的''1'
 3 . map() 函数 : 
　　新建一列 , map函数并不是df的方法 , 而是series的方法 
map()可以映射新一列数据
map()中可以使用lambd表达式
map()中可以使用方法，可以是自定义的方法
eg:map({to_replace:value})
注意 map()中不能使用sum之类的函数，for循环
dic = {
    'name':['周杰伦','李四','王五'],
    'salary':[1000,2000,3000]
df = DataFrame(data=dic)
#新增一列：给df中，添加一列，该列的值为中文名对应的英文名
#封装一个映射关系表
dic = {
    '周杰伦':'jay',
    '王五':'wangwu',
    '李四':'lisi'
df['ename'] = df['name'].map(dic)
(1) . map当做一种运算工具，至于执行何种运算，是由map函数的参数决定的（参数：lambda，函数）
使用自定义函数
#自定义函数
def after_salary(s):
    if s <= 500:
        return s
    else:
        return s - (s-500)*0.5
#超过500部分的钱缴纳50%的税
after_sal = df['salary'].map(after_salary)
df['after_salary'] = after_sal
使用lambda表达式
#员工的薪资集体提高500
df['salary'].map(lambda x:x+500)
 4 . 数据重排 --- 使用 .take() 函数排序
- take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序
- eg:df.take([1,3,4,2,5])
np.random.permutation(x)可以生成x个从0-(x-1)的随机数列
df.take(np.random.permutation(1000),axis=0).take(np.random.permutation(3),axis=1)
#np.random.permutation(1000) :把0,1000随机排列成列表
 当DataFrame规模足够大时，直接使用np.random.permutation(x)函数，就配合take()函数实现随机抽样
5 . 数据分类处理 [重点]
数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。
数据分类处理：
分组：先把数据分为几组
用函数处理：为不同组的数据应用不同的函数以转换数据
合并：把不同组得到的结果合并起来
数据分类处理的核心：
 - groupby()函数
 - groups属性查看分组情况
 - eg: df.groupby(by='item').groups
 (1) . 分组
#数据源
df = DataFrame({'item':['Apple','Banana','Orange','Banana','Orange','Apple'],
                'price':[4,3,3,2.5,4,2],
               'color':['red','yellow','yellow','green','green','green'],
               'weight':[12,20,50,30,20,44]})
df.groupby(by='item')
#查看分组情况
df.groupby(by='item').groups
分组后还可以聚合 : sum , mean 
#计算出苹果的平均价格
dic = {
    'Apple':3,
    'Banana':2.75,
    'Orange':3.5
df['mean_price'] = df['item'].map(dic)
df.groupby(by='item')['price'].mean()['Apple']
#按颜色查看各种颜色的水果的平均价格
df.groupby(by='color')['price'].mean()
dic={
    'green':2.83,
    'red':4,
    'yellow':3
df['color_mean_price'] = df['color'].map(dic)
 6 . 高级数据聚合 
　　使用groupby分组后，也可以使用transform和apply提供自定义函数实现更多的运算
df.groupby('item')['price'].sum() <==> df.groupby('item')['price'].apply(sum)
transform和apply都会进行运算，在transform或者apply中传入函数即可
transform和apply也可以传入一个lambda表达式
#求出各种水果价格的平均值
df.groupby(by='item')['price'].mean()
apply和transform
#定义执行方法
def fun(s):
    sum = 0
    for i in s:
        sum+=s
    return sum/s.size
#使用apply函数求出水果的平均价格
df.groupby(by='item')['price'].apply(fun) #给fun传入的参数是一个列表
#使用transform函数求出水果的平均价格
df.groupby(by='item')['price'].transform(fun) #给fun传入的参数是一个列表