快捷搜索:

您的位置:金莎娱乐 > 互联网 > 数码科学入门的5个技艺,Pandas的大概利用

数码科学入门的5个技艺,Pandas的大概利用

发布时间:2019-10-10 12:31编辑:互联网浏览(167)

    现在,我们已经有了布尔型Series对象,我们可以用括号将它传入DataFrame数据集中,得到筛选后的结果,如图3.2所示。

    Pandas数据处理

    函数应用和映射

    • numpy的ufuncs(元素级数组方法)
    • DataFrame的apply方法
    • 对象的applymap方法(因为Series有一个应用于元素级的map方法)
    # -*- coding: utf-8 -*- 
    
    import numpy as np
    from pandas import Series, DataFrame
    
    print('函数')
    frame = DataFrame(np.random.randn(4, 3),
                      columns = list('bde'),
                      index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
    print(frame)
    print(np.abs(frame))
    
    print('lambda以及应用')
    f = lambda x: x.max() - x.min()
    #列的最大值减去最小值
    print(frame.apply(f))
    #行的最大值减去最小值
    print(frame.apply(f, axis = 1))
    def f(x):
        return Series([x.min(), x.max()], index = ['min', 'max'])
    print(frame.apply(f))
    
    print('applymap和map')
    _format = lambda x: '%.2f' % x
    print(frame.applymap(_format))
    print(frame['e'].map(_format))
    

    可以指定列序列顺序

    frame = DataFrame(data,columns = ['year', 'state', 'pop'])

    虽然前两步对数据科学整个过程是非常必要的,但它们通常先于统计模型和程序处理。本书的后面章节将介绍不同的数据收集方法,在此之前,我们更加关注数据科学过程中“科学”的部分。所以,我们先从探索数据开始。

    2.导入json文件

    pandas的read_json方法将其转化为DataFrame格式

    DataFrame是一个表格型的数据结构,它含有一组有序的列,每列可以是不同值的类型(数值,字符串,布尔值等);DataFrame既有行索引也有列索引,也可以看做是Series组成的字典(共用一个索引),和其他类似的数据结构比, DataFrame中面向行和面向列的操作基本上是平衡的;

    DataFrame中的数据其实是以一个或多个二维块存放的(而不是列表、字典等一维数据结构), 虽然是以二维结构保存数据,但是仍然合一轻松地将其表示为更高维度的数据(层次化索引的表格型结构,这是pandas中许多高级数据处理功能的关键要素)

    df = pd.read_json('/Users/zhaoluyang/Desktop/Python_全国JSON.json')
    

    3.查看当前表的信息

    1 df.index#查看行索引信息
    2 df.columns#查看列信息
    3 df.head()#默认查看前5行元素,括号内可任意指定数字。
    4 df.tail()#默认指定最后5行元素,同样可指定数字。
    5 df.info()#查看表整体信息。
    6 df[['ZL_Job_id','工作地点']].head()#查看df表中'ZL_Job_id'和'工作地点'两列前5个元素。
    

    图片 1

     

     可以看见,总共有18326个行索引(18326行),15列columns分别为ZL_Job_id、公司名称、公司链接...

    通过去重进行数据清洗

    查看一列唯一值:df['A'].unique()
    查看是否有重复:df['A'].duplicated()
    删除重复数据:df.drop_duplicated(['A'])

    DataFrame与Series之间的运算

    1 ZRJwVLyzEJq1VAihDhYiow

    5.常用的函数示例

    #qw表示在df表中column=工作经验的列中,【工作经验==不限】的次数

    qw = df['工作经验'][df['工作经验']=='不限'].value_counts()
    

    #直接用value_counts()统计工作经验字段各个值出现的次数,并画图展示。PS:查询结果是Series形式(<class 'pandas.core.series.Series'>)

    df['工作经验'].value_counts().plot()
    

    一些有用的函数

    unique()、describe()、groupby()、zip()

    df['Names'].unique()
    

     

    结果:array(['Mary', 'Jessica', 'Bob', 'John', 'Mel'], dtype=object)

    df['Names'].describe()
    

     

    结果:
    count 1000
    unique 5
    top Bob
    freq 206
    Name: Names, dtype: object

    BabyDataSet = list(zip(names,births))
    BabyDataSet
    

     

    结果:[('Bob', 968), ('Jessica', 155), ('Mary', 77), ('John', 578), ('Mel', 973)]

     

    排序和排名

    • 对行或列索引进行排序
    • 对于DataFrame,根据任意一个轴上的索引进行排序
    • 可以指定升序降序
    • 按值排序
    • 对于DataFrame,可以指定按值排序的列
    • rank函数
    # -*- coding: utf-8 -*- 
    
    import numpy as np
    from pandas import Series, DataFrame
    
    print('根据索引排序,对于DataFrame可以指定轴。')
    obj = Series(range(4), index = ['d', 'a', 'b', 'c'])
    print(obj.sort_index())
    frame = DataFrame(np.arange(8).reshape((2, 4)),
                      index = ['three', 'one'],
                      columns = list('dabc'))
    print(frame.sort_index())
    print(frame.sort_index(axis = 1))
    print(frame.sort_index(axis = 1, ascending = False)) # 降序
    
    print('根据值排序')
    obj = Series([4, 7, -3, 2])
    print(obj.sort_values()) # order已淘汰
    
    print('DataFrame指定列排序')
    frame = DataFrame({'b':[4, 7, -3, 2], 'a':[0, 1, 0, 1]})
    print(frame)
    print(frame.sort_values(by = 'b')) # sort_index(by = ...)已淘汰
    print(frame.sort_values(by = ['a', 'b']))
    
    print('rank,求排名的平均位置(从1开始)')
    obj = Series([7, -5, 7, 4, 2, 0, 4])
    # 对应排名:-5(1), 0(2), 2(3), 4(4), 4(5), 7(6), 7(7)
    #rank 7为(6 7)/2
    print(obj.rank())
    print(obj.rank(method = 'first'))  # 去第一次出现,不求平均值。
    print(obj.rank(ascending = False, method = 'max')) # 逆序,并取最大值。所以-5的rank是7.
    frame = DataFrame({'b':[4.3, 7, -3, 2],
                      'a':[0, 1, 0, 1],
                      'c':[-2, 5, 8, -2.5]})
    print(frame)
    print(frame.rank(axis = 1))
    print('重复的索引')
    obj = Series(range(5), index = ['a', 'a', 'b', 'b', 'c'])
    print(obj.index.is_unique) # 判断是非有重复索引
    print(obj['a'].ix[0])
    print(obj.b.ix[1])
    df = DataFrame(np.random.randn(4, 3), index = ['a', 'a', 'b', 'b'])
    print(df)
    print(df.ix['b'].ix[0])
    print(df.ix['b'].ix[1])
    

    排名ranking

    obj = Series([7,-5,7,4,2,0,4])
    obj.rank()
    obj = Series([7,-5,7,4,2,0,4])
    obj.rank()
    0 6.5
    1 1.0
    2 6.5
    3 4.5
    4 3.0
    5 2.0
    6 4.5
    dtype: float64
    obj.rank(method = 'first')
    0 6.0
    1 1.0
    2 7.0
    3 4.0
    4 3.0
    5 2.0
    6 5.0
    dtype: float64
    obj.rank(method = 'max')
    0 7.0
    1 1.0
    2 7.0
    3 5.0
    4 3.0
    5 2.0
    6 5.0
    dtype: float64
    obj.rank(method = 'max',ascending = False)
    0 2.0
    1 7.0
    2 2.0
    3 4.0
    4 5.0
    5 6.0
    6 4.0
    dtype: float64
    obj.rank(method = 'min')
    0 6.0
    1 1.0
    2 6.0
    3 4.0
    4 3.0
    5 2.0
    6 4.0
    dtype: float64
    obj.rank(method = 'average')#默认

    ● 该列是自由文本吗?

    1.导入库

    1 import numpy as np
    2 import pandas as pd
    3 import matplotlib.pyplot as plt
    

    统计方法

    pandas 对象有一些统计方法。它们大部分都属于约简和汇总统计,用于从 Series 中提取单个值,或从 DataFrame 的行或列中提取一个 Series。
    比如 DataFrame.mean(axis=0,skipna=True) 方法,当数据集中存在 NA 值时,这些值会被简单跳过,除非整个切片(行或列)全是 NA,如果不想这样,则可以通过 skipna=False 来禁用此功能:

    图片 2

    常用方法选项

    图片 3

    常用描述和汇总统计函数1

    图片 4

    常用描述和汇总统计函数2

    import numpy as np
    from pandas import Series, DataFrame
    
    print('求和')
    df = DataFrame([[1.4, np.nan], [7.1, -4.5], [np.nan, np.nan], [0.75, -1.3]],
                  index = ['a', 'b', 'c', 'd'],
                  columns = ['one', 'two'])
    print(df)
    print(df.sum())  # 按列求和
    print(df.sum(axis = 1))  # 按行求和
    
    print('平均数')
    print(df.mean(axis = 1, skipna = False))
    print(df.mean(axis = 1))
    
    print('其它')
    print(df.idxmax())
    print(df.cumsum())
    print(df.describe())
    obj = Series(['a', 'a', 'b', 'c'] * 4)
    print(obj.describe())
    

    相关系数与协方差

    • 相关系数:相关系数是用以反映变量之间相关关系密切程度的统计指标。百度
      百科
    • 协方差:从直观上来看,协方差表示的是两个变量总体误差的期望。如果两个
      变量的变化趋势一致,也就是说如果其中一个大于自身的期望值时另外一个也
      大于自身的期望值,那么两个变量之间的协方差就是正值;如果两个变量的变
      化趋势相反,即其中一个变量大于自身的期望值时另外一个却小于自身的期望
      值,那么两个变量之间的协方差就是负值。

    另一种构建数据的形式叫嵌套字典

    pop = {
    'Nevada': {2001:2.4,2002:2.9},
    'Ohio': {2000:1.5,2001:1.7,2002:3.6}
    }

    frame3 = DataFrame(pop)

    ● unique:该列含有多少个非重复值。

    4.简单的数据规整

    经过第3步查看发现导入的表中ZL_Job_id一列是乱序版的,并没有按照1、2、3...的次序排列。 看了下json原文件发现也是乱序的,但是为了看起来美观和统一,我需要把此列按正常序号排列, 然后将此列作为列索引。(因为这一列在mysql里就是我手动添加做索引来用的) 此时大致需要几个步骤:

    1.将df中系统自动添加的索引替换成列ZL_Job_id。

    2.将原来的‘ZL_Job_id’列删除。

    3.给新的索引列排序。(也可以对数据列排序df.sort_values([‘ZL_Job_id’]))

     

    1 df.index=df['ZL_Job_id']
    2 del(df['ZL_Job_id'])
    3 df1 = df.sort_index()#直接df.sort_index()可返回索引的结果,但之后df还是原来的结构
    4 df1[['职位名称','工作地点']].head()
    

    图片 5

    重命名DataFrame的Index

    • df.index = Series(list('abc'))直接赋一个新值
    • df.index = df.index.map(str.lower)
    • df = df.rename(index=str.lower,columns=str.lower)
    • df = df.rename(index={'A' : 'a'})

    函数应用和映射

    frame = DataFrame(np.random.randn(4,3),columns = list('bde'),index = ['Utah', 'Ohio', 'Texas', 'Oregon'])

    np.abs(frame)

    f = lambda x: x.max() - x.min()

    frame.apply(f)

    np.mean(frame,axis = 1)
    np.sum(frame,axis = 1)

    def f(x):
    return Series([x.min(),y.max()],index=['min','max'])

    frame.apply(f)

    format = lambda x: '%.2f' % x

    frame.applymap(format)

    1.1.1 提出有意思的问题

    Concatenate和Combine

    np.concatenate(arr1,arr2)#默认是竖着增加,axis=1时横着增加,即增加列
    combine_first,它实现既不是行之间的连接,也不是列之间的连接,它在修正数据,用一个DataFrame来填补前面的DataFrame中NAN的数据
    Merge, join, and concatenate官方文档说明:http://pandas.pydata.org/pandas-docs/stable/merging.html

    Series和DataFrame的基本功能

    ● 很明显,每一行代表一条用户的评价。我们还会查看每一行和每一列的数据类型。我们使用DataFrame的shape方法查看数据集的大小,如下所示。

    pandas中主要的index对象

    图片 6

    index

    Index的方法和属性

    图片 7

    method1

    图片 8

    method2

    索引、选取和过滤

    好了,我们已经介绍了很多内容,下面看一些具体的例子。

    Series和DataFrame排序

    Series排序

    • sort_values根据值大小排序,默认是升序
    • sort_index 根据索引排序
      DataFrame排序
    • sort_values根据值大小排序,默认是升序

    index

    《深入浅出数据科学》

    pandas的数据处理常用方法总结

    默认情况下,DataFrame与Series之间的算术运算会将Series的索引匹配到DataFrame的列,然后沿着行一致向下广播。

    yelp_raw_data['type'].describe()

    pandas的数据结构

    • Series
      Series是一维标记数组,可以存储任意数据类型,如整型、字符串、浮点型和Python对象等,轴标一般指索引。Series的字符串表现形式为:索引在左边,值在右边。
      Series、Numpy中的一维Array、Python基本数据结构List区别:List中的元素可以是不同的数据类型,而Array和Series中则只允许存储相同的数据类型,这样可以更有效的使用内存,提高运算效率。
    # -*- coding: utf-8 -*- 
    
    from pandas import Series
    
    print('用数组生成Series')
    obj = Series([4, 7, -5, 3])
    print(obj)
    print(obj.values)
    print(obj.index)
    
    print('指定Series的index')
    obj2 = Series([4, 7, -5, 3], index = ['d', 'b', 'a', 'c'])
    print(obj2)
    print(obj2.index)
    print(obj2['a'])
    obj2['d'] = 6
    print(obj2[['c', 'a', 'd']])
    print(obj2[obj2 > 0])  # 找出大于0的元素
    print('b' in obj2) # 判断索引是否存在
    print('e' in obj2)
    
    print('使用字典生成Series')
    sdata = {'Ohio':45000, 'Texas':71000, 'Oregon':16000, 'Utah':5000}
    obj3 = Series(sdata)
    print(obj3)
    
    print('使用字典生成Series,并额外指定index,不匹配部分为NaN。')
    states = ['California', 'Ohio', 'Oregon', 'Texas']
    obj4 = Series(sdata, index = states)
    print(obj4)
    
    print('Series相加,相同索引部分相加。')
    print(obj3   obj4)
    
    print('指定Series及其索引的名字')
    obj4.name = 'population'
    obj4.index.name = 'state'
    print(obj4)
    
    print('替换index')
    obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
    print(obj)
    
    • DateFrame
      DataFrame是二维标记数据结构,列可以是不同的数据类型。它是最常用的pandas对象,像Series一样可以接收多种输入:lists、dicts、series和DataFrame等。初始化对象时,除了数据还可以传index和columns这两个参数。DataFrame既有行索引也有列索引,它可以被看做由Series组成的字典(共用同一个索引)。
      注意:
      (1) 在pandas中用函数 isnull 和 notnull 来检测数据丢失:pd.isnull(a)、pd.notnull(b)。
      Series也提供了这些函数的实例方法:a.isnull()。
      (2) Pandas提供了大量的方法能够轻松的对Series,DataFrame和Panel对象进行各种符合各种逻辑关系的合并操作。如:Concat、Merge (类似于SQL类型的合并)、Append (将一行连接到一个DataFrame上)。
      (3) DataFrame中常常会出现重复行,DataFrame的duplicated方法返回一个布尔型Series,表示各行是否是重复行;还有一个drop_duplicated方法,它返回一个移除了重复行的DataFrame。
      常用DateFrame的初始化方法

    图片 9

    初始化

    # -*- coding: utf-8 -*- 
    
    import numpy as np
    from pandas import Series, DataFrame
    
    print('用字典生成DataFrame,key为列的名字。')
    data = {'state':['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
            'year':[2000, 2001, 2002, 2001, 2002],
            'pop':[1.5, 1.7, 3.6, 2.4, 2.9]}
    print(DataFrame(data))
    print(DataFrame(data, columns = ['year', 'state', 'pop'])) # 指定列顺序
    
    print('指定索引,在列中指定不存在的列,默认数据用NaN。')
    frame2 = DataFrame(data,
                        columns = ['year', 'state', 'pop', 'debt'],
                        index = ['one', 'two', 'three', 'four', 'five'])
    print(frame2)
    print(frame2['state'])
    print(frame2.year)#访问的不同方式
    print(frame2.ix['three'])
    frame2['debt'] = 16.5 # 修改一整列
    print(frame2)
    frame2.debt = np.arange(5)  # 用numpy数组修改元素
    print(frame2)
    
    print('用Series指定要修改的索引及其对应的值,没有指定的默认数据用NaN。')
    val = Series([-1.2, -1.5, -1.7], index = ['two', 'four', 'five'])
    frame2['debt'] = val
    print(frame2)
    
    print('赋值给新列')
    frame2['eastern'] = (frame2.state == 'Ohio')  # 如果state等于Ohio为True
    print(frame2)
    print(frame2.columns)
    print
    
    print('DataFrame转置')
    pop = {'Nevada':{2001:2.4, 2002:2.9},
            'Ohio':{2000:1.5, 2001:1.7, 2002:3.6}}
    frame3 = DataFrame(pop)
    print(frame3)
    print(frame3.T)
    
    print('指定索引顺序,以及使用切片初始化数据。')
    print(DataFrame(pop, index = [2001, 2002, 2003]))
    pdata = {'Ohio':frame3['Ohio'][:-1], 'Nevada':frame3['Nevada'][:2]}
    print(DataFrame(pdata))
    
    print('指定索引和列的名称')
    frame3.index.name = 'year'
    frame3.columns.name = 'state'
    print(frame3)
    print(frame3.values)
    print(frame2.values)
    
    import numpy as np
    import pandas as pd
    import sys
    from pandas import Series, DataFrame, Index
    
    print('获取index')
    obj = Series(range(3), index = ['a', 'b', 'c'])
    index = obj.index
    print(index[1:])
    try:
        index[1] = 'd'  # index对象read only
    except:
        print(sys.exc_info()[0])
    
    print('使用Index对象')
    index = Index(np.arange(3))
    obj2 = Series([1.5, -2.5, 0], index = index)
    print(obj2)
    print(obj2.index is index)
    
    print('判断列和索引是否存在')
    pop = {'Nevada':{20001:2.4, 2002:2.9},
            'Ohio':{2000:1.5, 2001:1.7, 2002:3.6}}
    frame3 = DataFrame(pop)
    print(frame3)
    print('Ohio' in frame3.columns)
    print('2003' in frame3.index)
    

    使用reindex()可以重新索引行,使用colunms关键字可以重新索引列:

    obj3.reindex(columns = ['Texas', 'Utah', 'California'])

    ● business_id:本列看起来是每条评价对应的交易的唯一识别码。本列是定类尺度,因为识别码没有天然的顺序。

    基本功能 重新索引

    • 创建一个适应新索引的新对象,该Series的reindex将会根据新索引进行重排。如果某个索引值当前不存在,就引入缺失值
    • 对于时间序列这样的有序数据,重新索引时可能需要做一些插值处理。method选项即可达到此目的。

    图片 10

    reindex参数

    # -*- coding: utf-8 -*- 
    
    import numpy as np
    from pandas import DataFrame, Series
    
    print('重新指定索引及顺序')
    obj = Series([4.5, 7.2, -5.3, 3.6], index = ['d', 'b', 'a', 'c'])
    print(obj)
    obj2 = obj.reindex(['a', 'b', 'd', 'c', 'e'])
    print(obj2)
    print(obj.reindex(['a', 'b', 'd', 'c', 'e'], fill_value = 0))  # 指定不存在元素的默认值
    
    print('重新指定索引并指定填元素充方法')
    obj3 = Series(['blue', 'purple', 'yellow'], index = [0, 2, 4])
    print(obj3)
    #ffill用前一行相同列的数值填充
    print(obj3.reindex(range(6), method = 'ffill'))
    
    print('对DataFrame重新指定索引')
    frame = DataFrame(np.arange(9).reshape(3, 3),
                      index = ['a', 'c', 'd'],
                      columns = ['Ohio', 'Texas', 'California'])
    print(frame)
    frame2 = frame.reindex(['a', 'b', 'c', 'd'])
    print(frame2)
    print
    
    print('重新指定column')
    states = ['Texas', 'Utah', 'California']
    print(frame.reindex(columns = states))
    
    print('对DataFrame重新指定索引并指定填元素充方法')
    print(frame.reindex(index = ['a', 'b', 'c', 'd'],
                        method = 'ffill',
                        columns = states))
    print(frame.ix[['a', 'b', 'd', 'c'], states])
    

    丢弃某些项
    丢弃某条轴上的一个或多个项很简单,只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑,所以drop方法返回的是一个在指定轴上删除了指定值的新对象

    import numpy as np
    from pandas import Series, DataFrame
    
    print('Series根据索引删除元素')
    obj = Series(np.arange(5.), index = ['a', 'b', 'c', 'd', 'e'])
    new_obj = obj.drop('c')
    print(new_obj)
    print(obj.drop(['d', 'c']))
    
    print('DataFrame删除元素,可指定索引或列。')
    data = DataFrame(np.arange(16).reshape((4, 4)),
                      index = ['Ohio', 'Colorado', 'Utah', 'New York'],
                      columns = ['one', 'two', 'three', 'four'])
    print(data)
    print(data.drop(['Colorado', 'Ohio']))
    print(data.drop('two', axis = 1))
    print(data.drop(['two', 'four'], axis = 1))
    

    索引、选取、过滤

    • Series索引(obj[...])的工作方式类似于NumPy数组的索引,只不过Series的索引值不只是整数。
    • 利用标签的切片运算与普通的Python切片运算不同,其末端是包含的(inclusive)。
    • 对DataFrame进行索引其实就是获取一个或多个列
    • 为了在DataFrame的行上进行标签索引,引入了专门的索引字段ix。

    图片 11

    DataFrame索引

    # -*- coding: utf-8 -*- 
    
    import numpy as np
    from pandas import Series, DataFrame
    
    print('Series的索引,默认数字索引可以工作。')
    obj = Series(np.arange(4.), index = ['a', 'b', 'c', 'd'])
    print(obj['b'])
    print(obj[3])
    print(obj[[1, 3]])
    print(obj[obj < 2])
    
    print('Series的数组切片')
    print(obj['b':'c'] ) # 闭区间
    obj['b':'c'] = 5
    print(obj)
    
    print('DataFrame的索引')
    data = DataFrame(np.arange(16).reshape((4, 4)),
                      index = ['Ohio', 'Colorado', 'Utah', 'New York'],
                      columns = ['one', 'two', 'three', 'four'])
    print(data)
    print(data['two']) # 打印列
    print(data[['three', 'one']])
    print(data[:2])
    print(data.ix['Colorado', ['two', 'three']]) # 指定索引和列
    print(data.ix[['Colorado', 'Utah'], [3, 0, 1]])
    print(data.ix[2]) # 打印第2行(从0开始)
    print(data.ix[:'Utah', 'two']) # 从开始到Utah,第2列。
    
    print('根据条件选择')
    print(data[data.three > 5])
    print(data < 5)  # 打印True或者False
    data[data < 5] = 0
    print(data)
    

    当重新索引时不存在,就会引入缺失值,也可以填入默认值

    obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'],fill_value = 0)

    describe函数用于输出指定列的快速统计信息。请注意,Pandas自动识别出business_id列为定性数据,所以给出的快速统计是有意义的。实际上,当describe函数作用于定性数据时,我们将得到以下4个统计信息。

    时间序列

    pd.date_range(start=None, end=None, periods=None, freq='D', tz=None, normalize=False, name=None, closed=None, **kwargs)
    Docstring:
    Return a fixed frequency datetime index, with day (calendar) as the default
    frequency
    
    Parameters
    ----------
    start : string or datetime-like, default None
        Left bound for generating dates
    end : string or datetime-like, default None
        Right bound for generating dates
    periods : integer or None, default None
        If None, must specify start and end
    freq : string or DateOffset, default 'D' (calendar daily)
        Frequency strings can have multiples, e.g. '5H'
    tz : string or None
        Time zone name for returning localized DatetimeIndex, for example
    Asia/Hong_Kong
    normalize : bool, default False
        Normalize start/end dates to midnight before generating date range
    name : str, default None
        Name of the resulting index
    closed : string or None, default None
        Make the interval closed with respect to the given frequency to
        the 'left', 'right', or both sides (None)
    

    Pandas中的resample,重新采样,是对原样本重新处理的一个方法,是一个对常规时间序列数据重新采样和频率转换的便捷的方法。
    参照:http://blog.csdn.net/wangshuang1631/article/details/52314944

    关键字del 用于删除列

    我们已经知道business_id列有10 000个值,但千万别被骗了!这并不意味着真的有10 000条交易评价,它仅仅意味着business_id列被填充了10 000次。

    Pandas是面板数据(Panel Data)的简写。它是Python最强大的数据分析和探索工具,因金融数据分析工具而开发,支持类似SQL的数据增删改查,支持时间序列分析,灵活处理缺失数据。

    reindex的一些参数:

    ● 真:该行满足条件;

    通过apply进行数据预处理

    df['A'] = df['A'].apply(str.upper)

    如果传入的列在数据中找不到,就会产生NA值

    frame = DataFrame(data,columns = ['year','state','pop','debt'])

    yelp_raw_data['business_id']# grab a single column of the Dataframe

    算术运算和数据对齐
    # -*- coding: utf-8 -*- 
    
    import numpy as np
    from pandas import Series, DataFrame
    
    print('加法')
    s1 = Series([7.3, -2.5, 3.4, 1.5], index = ['a', 'c', 'd', 'e'])
    s2 = Series([-2.1, 3.6, -1.5, 4, 3.1], index = ['a', 'c', 'e', 'f', 'g'])
    print(s1)
    print(s2)
    print(s1   s2)
    
    print('DataFrame加法,索引和列都必须匹配。')
    df1 = DataFrame(np.arange(9.).reshape((3, 3)),
                    columns = list('bcd'),
                    index = ['Ohio', 'Texas', 'Colorado'])
    df2 = DataFrame(np.arange(12).reshape((4, 3)),
                    columns = list('bde'),
                    index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
    print(df1)
    print(df2)
    print(df1   df2)
    
    print('数据填充')
    df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns = list('abcd'))
    df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns = list('abcde'))
    print(df1)
    print(df2)
    print(df1.add(df2, fill_value = 0))
    print(df1.reindex(columns = df2.columns, fill_value = 0))
    
    print('DataFrame与Series之间的操作')
    arr = np.arange(12.).reshape((3, 4))
    print(arr)
    print(arr[0])
    print(arr - arr[0])
    frame = DataFrame(np.arange(12).reshape((4, 3)),
                      columns = list('bde'),
                      index = ['Utah', 'Ohio', 'Texas', 'Oregon'])
    series = frame.ix[0]
    print(frame)
    print(series)
    print(frame - series)
    series2 = Series(range(3), index = list('bef'))
    print(frame   series2)
    series3 = frame['d']
    print(series3)
    print(frame.sub(series3, axis = 0))  # 按列减
    

    get_value, set_value 根据行标签和列标签选取单个值

    我们需要识别每一列的数据层次、定性/定量属性等。分类结果可能随着分析的不断深入而改变,但越早开始这一步越好。

    DataFrame的Merge操作

    pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False)
    Docstring:
    Merge DataFrame objects by performing a database-style join operation by
    columns or indexes.
    
    If joining columns on columns, the DataFrame indexes *will be
    ignored*. Otherwise if joining indexes on indexes or indexes on a column or
    columns, the index will be passed on.
    
    Parameters
    ----------
    left : DataFrame
    right : DataFrame
    how : {'left', 'right', 'outer', 'inner'}, default 'inner'
        * left: use only keys from left frame (SQL: left outer join)
        * right: use only keys from right frame (SQL: right outer join)
        * outer: use union of keys from both frames (SQL: full outer join)
        * inner: use intersection of keys from both frames (SQL: inner join)
    on : label or list
        Field names to join on. Must be found in both DataFrames. If on is
        None and not merging on indexes, then it merges on the intersection of
        the columns by default.
    left_on : label or list, or array-like
        Field names to join on in left DataFrame. Can be a vector or list of
        vectors of the length of the DataFrame to use a particular vector as
        the join key instead of columns
    right_on : label or list, or array-like
        Field names to join on in right DataFrame or vector/list of vectors per
        left_on docs
    left_index : boolean, default False
        Use the index from the left DataFrame as the join key(s). If it is a
        MultiIndex, the number of keys in the other DataFrame (either the index
        or a number of columns) must match the number of levels
    right_index : boolean, default False
        Use the index from the right DataFrame as the join key. Same caveats as
        left_index
    sort : boolean, default False
        Sort the join keys lexicographically in the result DataFrame
    suffixes : 2-length sequence (tuple, list, ...)
        Suffix to apply to overlapping column names in the left and right
        side, respectively
    copy : boolean, default True
        If False, do not copy data unnecessarily
    indicator : boolean or string, default False
        If True, adds a column to output DataFrame called "_merge" with
        information on the source of each row.
        If string, column with information on source of each row will be added to
        output DataFrame, and column will be named value of string.
        Information column is Categorical-type and takes on a value of "left_only"
        for observations whose merge key only appears in 'left' DataFrame,
        "right_only" for observations whose merge key only appears in 'right'
        DataFrame, and "both" if the observation's merge key is found in both.
    
        .. versionadded:: 0.17.0
    
    Examples
    --------
    
    >>> A              >>> B
        lkey value         rkey value
    0   foo  1         0   foo  5
    1   bar  2         1   bar  6
    2   baz  3         2   qux  7
    3   foo  4         3   bar  8
    
    >>> A.merge(B, left_on='lkey', right_on='rkey', how='outer')
       lkey  value_x  rkey  value_y
    0  foo   1        foo   5
    1  foo   4        foo   5
    2  bar   2        bar   6
    3  bar   2        bar   8
    4  baz   3        NaN   NaN
    5  NaN   NaN      qux   7
    
    Returns
    -------
    merged : DataFrame
        The output type will the be same as 'left', if it is a subclass
        of DataFrame.
    

    Series

    obj = Series([4,7,-5,3])

    obj2 = Series([4,7,-5,3],index = ['a','b','c','d'])

    sdata = {'Ohio':35000, 'Texas':71000, 'Oregon':16000, 'Utah': 5000}

    obj3 = Series(sdata)

    filtered_dataframe = yelp_raw_data[text_is_the_duplicate]

    使用add算术加时用fill_value可以避免引入NA值

    df1 = DataFrame(np.arange(12).reshape((3,4)),columns=list('abcd'))
    df2 = DataFrame(np.arange(20).reshape((4,5)),columns=list('abcde'))

    df2 df1
    a b c d e
    0 0.0 2.0 4.0 6.0 NaN
    1 9.0 11.0 13.0 15.0 NaN
    2 18.0 20.0 22.0 24.0 NaN
    3 NaN NaN NaN NaN NaN
    df1.add(df2,fill_value = 0)
    a b c d e
    0 0.0 2.0 4.0 6.0 4.0
    1 9.0 11.0 13.0 15.0 9.0
    2 18.0 20.0 22.0 24.0 14.0
    3 15.0 16.0 17.0 18.0 19.0

    数据并不完美。很多时候,人工或机械的错误将导致数据缺失。当这种错误发生时,作为数据科学家,我们需要决定如何处理这些错误。

    copy ...

    还记得这一列吗?统计显示该列的列值只有一个:review。

    列索引

    frame['state']
    frame.year

    本书可以帮助读者把数学、编程和商业分析联系起来。通过学习这本书,读者有信心探究和解答复杂的数据科学问题,从抽象的原始的统计,发掘出切实可行的观点和想法。本书适合缺乏数学知识的编程人员,或者是拥有数学技能、想投身数据科学领域的人士阅读使用。​返回搜狐,查看更多

    对行进行标签索引,可以使用ix

    data.ix[2]
    data.ix['Colorado',[1,2]]
    data.ix[['Colorado','Utah'],[3,0,1]]

    # top JokKtdXU7zXHcr20Lrk29A

    Series的索引

    obj = Series(np.arange(4.),index = ['a','b','c','d'])
    obj['a']
    obj[1]
    obj[2:4]
    obj[['a','c','d']]
    obj[obj > 1]

    ● 假:该行不满足条件。

    对于DataFrame来说也一样

    # tope Ta5KD-LTgQv6UT1Zmijmw

    自动的数据对齐操作在不重叠的索引处引入NA值。

    图片 12

    method

    ● stars:本列看起来(别担心,我们随后会对它进行深入的分析)是评价者给每一个餐馆的最终评分。本列是有次序的定性数据,因此属于定序尺度。

    通过布尔型DataFrame进行索引:

    data < 5

    data[data < 5] = 0

    2 6oRAC4uyJCsJl1X0WZpVSA

    构建DataFrame

    data = {'state': ['Ohio','Ohio','Ohio','Nevada','Nevada'],
    'year': [2000,2001,2002,2001,2001],
    'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

    frame = DataFrame(data) #自动加上索引

    以下是重复的文本:

    可以指定行的索引

    frame = DataFrame(data,columns = ['year','state', 'pop'],index = ['one', 'two', 'three', 'four','five',])

    1.2.2 数据集1:Yelp点评数据

    丢弃指定轴上的项

    我们需要确认数据是否是行列结构。大部分情况下,我们处理的数据都是结构化数据。本书中,超过90%的例子都是结构化数据。尽管如此,在我们进行更深入的数据分析之前,还是要弄清楚这个最基本的问题。

    icol,irow ...

    # the filtered Dataframe

    不存在的列赋值会创建新的列

    ● 是否有缺失值?

    重新索引

    obj = Series([4.5,7.2,-5.3,3.6],index = ['b', 'c', 'a', 'd'])
    obj2 = obj.reindex(['a','b','c','d','e'])

    yelp_raw_data['business_id'].describe()

    DataFrame的索引汇总

    问题2:每一行代表什么?

    对于非数值型数据,describe会产生另外一种汇总统计:

    obj = Series(['a','b','c','d'] * 4)
    obj.describe()
    count 16
    unique 4
    top b
    freq 4
    dtype: object
    obj.describe()
    count 16.000000
    mean 2.500000
    std 1.154701
    min 1.000000
    25% 1.750000
    50% 2.500000
    75% 3.250000
    max 4.000000
    dtype: float64

    当然是合理的!因为该列是每条评价的唯一识别码,每一行代表独立的、不重复的点评,所以review_id列含有10 000个不重复值是合理的。

    相关系数和协方差 ---------------未完备-----------------

    from pandas_datareader import data as web
    all_data = {}
    for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOD']:
    all_data[ticker] = web.get_data_yahoo(ticker,'1/1/2000','1/1/2010')
    price = DataFrame({tic: data['Adj Close'] for tic,data in all_data.iteritems()})
    volume = DataFrame({tic: data['Volume'] for tic,data in all_data.iteritems()})

    ● 结果显示,数据集有10 000行和10列。换言之,数据集有10 000个观测值和10个观测特征。

    灵活额算术方法

    add()
    sub()
    div()
    mul()

    ● type:本列前5行均为“review”,我们猜测它是标记每行是否为“review”的列,也就是说很可能存在不是“review”的行。我们随后将进行更深入的分析。本列属于定类尺度。

    obj.ix[val1,val2] 同时选取列和行

    count和unique值均为10 000。请你思考几秒,这个结果合理吗?请结合每一行和每一列代表的意思。(插入《Jeopardy》的主题曲。)

    from pandas import Series, DataFrame

    真和假的判断依据如下。

    除了填入默认值fill_value, 其他的method,包括ffill或pad向前填充值,bfill或backfill向后填充值

    obj3 = Series('blue','green', 'yellow',index =[0,2,4])
    obj3.reindex(range(6),method = 'ffill')

    ● 使用isnull方法判断是否有缺失值。比如,对于名为awesome_dataframe的DataFrame数据集,使用Python代码awesome_dataframe.isnull().sum()可显示每一列的缺失值总数。

    level ...

    df.idxmax()
    df.idxmin()# 达到最大值或最小值的索引

    df.cumsum()# 累加

    df.describe() # 一次性产生多个汇总统计
    one two
    count 3.000000 2.00000
    mean 3.116667 -2.75000
    std 3.551174 2.05061
    min 0.750000 -4.20000
    25% 1.075000 -3.47500
    50% 1.400000 -2.75000
    75% 4.300000 -2.02500
    max 7.200000 -1.30000

    虽然这些步骤更多是写给业余分析师的指引,但它们同样是数据科学家,甚至更严格的商业分析和学术分析的基础。每一位数据科学家都理解这些步骤的重要意义,会在实践过程中严格遵守它们。

    如果某个索引值在DataFrame的列或Series的索引中找不到,则参与运算的两个对象就会被重新索引形成并集。

    当我们读取数据集时,Pandas将创建一个名为DataFrame类型的对象。你可以将它想象成Python版本的电子表格(但是更好用)。

    xs方法 根据标签选取单行和单列,并返回一个Series

    ● 数据源是非常好的行列结构,我们可以认为它是有组织格式的。

    汇总和计算描述统计

    df = DataFrame([[1.4,np.nan],[7.2,-4.2],[np.nan,np.nan],[0.75,-1.3]],index = ['a','b','c','d'],columns = ['one','two'])

    df.sum()#所有的行求sum
    df.sum(axis = 1) # 所有的列求sum

    import pandas as pd

    获取列序列

    frame.columns

    top This review is for the chain in general.

    缺失值会在算数运算中传播

    unique 6403

    import pandas as pd

    Once it is I will put this review thereas well……."

    列可以通过赋值的方式进行修改,数组赋值时长度必须一致,如果赋值的是一个Series,就会精确到索引,所有的空位会填上缺失值。

    frame.debt = 16.8

    # count 10000

    对于DataFrame,可以删除任意轴上的索引值:

    data = DataFrame(np.arange(16).reshape(4,4),index = ['Ohio', 'California', 'Utah', 'New York'],
    columns = [1,2,3,4])

    data.drop('Ohio')
    data.drop(['Ohio','New York'])
    data.drop('Ohio',axis = 0)
    data.drop(1,axis = 1)
    data.drop([1,2],axis = 1)

    ● 导入Pandas包,并缩写为pd。

    对象相加时获得是并集

    s1 = Series([1,2,3,4,5],index = ['a', 'c', 'd', 'e','f'])
    s2 = Series([2,3,4,5,6], index = ['a','b','c','d','e'])

    s1 s2

    a 3.0
    b NaN
    c 6.0
    d 8.0
    e 10.0
    f NaN
    dtype: float64

    第一,你不会希望在没有找到数据之前,就被自己的偏见影响。第二,获取数据可能涉及公开渠道和私有渠道,因此不会轻松和显而易见。

    skipna 排除缺失值,默认值为True

    一旦你确定了需要关注的问题,接下来就需要全力收集回答上述问题所需要的数据。正如之前所说,数据可能来自多个数据源,所以这一步非常具有挑战性。

    注意 NA值会自动被排除,除非整个切片都是NA值,

    df.mean(axis = 1, skipna = False)

    (4)数据建模;

    DataFrame的索引

    data = DataFrame(np.arange(16).reshape(4,4),index = ['Ohio','Colorado', 'Utah','New York'],
    columns = [1,2,3,4])

    ● 每一列代表什么?

    行索引

    frame.ix['three']

    filtered_dataframe​

    pandas中的缺失用NaN来表示,

    pd.isnull(obj4)
    pd.notnull(obj4)

    obj4.isnull()
    obj4.name = 'population'
    obj4.index.name = 'state'

    1.2.1 数据探索的基本问题

    Series的索引可以通过赋值的方式就地修改

    本文将重点关注第(3)、(4)、(5)步。

    obj.ix[:,val] 选取单个列或列子集

    ● review_id: 本列看起来是每条评价的唯一识别码。本列同样属于定类尺度,因为识别码没有天然的顺序。

    按值来进行排序可以用order() ############存在问题

    obj = Series(np.random.randn(5))

    frame = DataFrame({'b':[4,7,-3,2], 'a':[0,1,0,1]})
    frame.sort_index(by = 'b')
    frame.sort_index(by = ['a', 'b'])

    问题5:是否需要对某些列进行数据转换?

    可以进行转置

    frame3.T

    count 10000

    obj[val] 选取单个列或一组列

    DataFrame

    通过切片或者布尔型选取行

    data[:2]
    data[data[3]>5]

    yelp_raw_data['user_id'].describe()

    如果只传入一个字典,则结果Series中的索引就是原字典的键。

    states = ['California','Ohio', 'Oregon', 'Texas']
    obj4 = Series(sdata, index = states)

    对于定类尺度数据,我们通常观察以下几个特征,以决定是否需要进行数据转换。

    level ...

    freq 38

    sort_index默认是升序排序的,也可以降序排序,关键字ascending = False

    frame.sort_index(axis = 1, ascending = False)

    ● 读取文件yelp.csv,并命名为yelp_raw_data。

    对于DataFrame来说可以对任意轴进行排序

    frame = DataFrame(np.arange(8).reshape(2,4),index = ['One','Two'], columns = ['a','c','b','d'])

    frame.sort_index(axis = 0)# 表示对行标签进行索引
    frame.sort_index(axis = 1) # 表示对列标签进行索引

    freq 2

    可以为DataFrame设置index and columns 的 name

    frame3.index.name = 'year'
    frame3.columns.name = 'state'

    ● 数据是有组织格式的,还是无组织格式的?

    行和列可以同时重新索引:

    obj3.reindex(index = [],method = 'ffill', columns = [])

    图片 13

    axis 约简的轴,行用0,列用1

    接下来使用type函数检查该列是否是Series类型。

    如果要匹配行且在列上广播,必须使用算术运算方法

    frame.sub(series,axis = 0)

    对于定类尺度列,列名描述了该列的含义,数据类型是定性数据。在Yelp数据集中,定类尺度列有business_id、review_id、text、type和user_id。我们使用Pandas进行更深入的分析,如下所示:

    columns

    每当接触新数据集时,不论你是否熟悉它,在初次进行分析前回答以下问题都非常有必要。

    Index对象的主要类别和方法和属性查看p126

    统计指标unique显示数据集有4 174个不重复的餐馆,其中被评价次数最多的餐馆是JokKtdXU7zXHcr20Lrk29A,总评价次数是37次。

    排序和排名

    obj = Series(range(4), index=['b','c','d','a'])
    obj.sort_index()

    "This review is for the chain in general.

    DataFrame

    我们已经找出了重复文本,下面来创建判断真或假的Series对象。

    索引对象

    index #不可修改
    index = pd.Index(np.arange(3))

    我们马上发现这可能是同一个人给隶属于同一家连锁餐馆的两家店撰写的两条完全相同的评价。但是,在没有进一步证据之前,这仅仅是猜测。

    算术运算和数据对齐

    事实上,这是Series对象一个非常有意思的功能。当我们将Series对象和另一个对象做比较时,相当于将Series中每个元素和该对象做比较,返回的结果是一个和Series对象长度相同的新Series对象。非常便捷!

    reindex

    ​图3.1 数据的表头

    limit 前向或者后向填充时的最大填充量

    一旦得到数据,我们将使用第2章学习的知识,将数据归类到不同的数据类型。这是数据科学5个步骤中最关键的一步。当这一步骤完成时,分析师通常已经花费了数小时学习相关的领域知识,利用代码或其他工具处理和探索数据,对数据蕴含的价值有了更好的认识。

    单索引获取的是列

    data[1]
    data[[1,2]]

    ● count:该列含有多少个值。

    其他的统计汇总详见P114

    duplicate_text = yelp_raw_data['text'].describe()['top']

    Series的赋值

    obj['a':'c'] = 5

    unique 1

    obj.ix[val] 选取单个行或者一组行

    问题4:是否有缺失值?

    约简方法的常用选项

    ● 每一行代表什么?

    带有重复值的轴索引

    obj = Series(range(5),index = ['a','a','b','b','c'])
    obj.index.is_unique#index的值是否唯一

    obj['a']
    obj['c']

    1.1.3 探索数据

    对于DataFrame来说,行和列上的对齐操作同时发生

    自始至终,我们的核心问题是:我们能从前期的推理统计中得到哪些信息?我们希望对数据的理解比初次接触时更深。

    drop方法返回的是一个在指定轴上删除了指定值的新对象

    obj = Series(np.arange(5), index = ['a','b','c','d','e'])
    obj_new = obj.drop('c')
    obj_new = obj.drop(['c','d'])

    ● date:本列是每条评价的提交日期。请注意,它只精确到了年、月和日。虽然时间通常被认为是连续数据,但本列应该被视为离散数据。本列属于定序尺度,因为日期有天然的顺序。

    注意,切片运算obj[1:2]包括2,obj['a':'c']包括'c'

    text列有点意思,它是用户撰写的评价。理论上,我们认为它和review_id列一样是不重复的文本,因为如果两个不同的人撰写的评价完全一致会非常诡异。

    利用ix的索引标签功能可以达到相同的功能:

    obj3.ix(['a','b','c','d'],['Texas','Utah','California'])

    0 9yKzy9PApeiPPOUJEtnvkg

    原标题:数据科学入门的5个技巧

    unique 9998

    # pandas.core.series.Series

    数据探索的过程并不简单。它涉及识别数据类型、转换数据类型、使用代码系统性提高数据质量为模型做准备的能力。为了更好地演示和讲解数据探索的艺术,我将使用Python的Pandas包,对几个不同的数据集进行探索。在此过程中,我们将看到多种数据处理技巧。

    探索数据

    责任编辑:

    5 -yxfBYGB6SEqszmxJxd97A

    但是,数据集中恰恰有两条评价完全一样!下面让我们花点时间学习一下DataFrame的数据筛选功能,然后再研究这一奇怪现象。

    (5)可视化和分享结果。

    请注意,数据集有10列。

    在Python中,我们可以像对1和0一样,对真和假进行相加或相减。比如,真 假-真 假 真==1。所以,我们可以通过将Series对象的值相加来验证其是否正确。由于只有两行文本重复,所以Series对象合计值应为2,如下所示:

    毫无疑问,可视化和分享结果是最重要的一步。分析结果也许看起来非常明显和简单,但将其总结为他人易于理解的形式比看起来困难得多。我们将通过一些案例,演示糟糕的分享和改善后的效果。

    yelp_raw_data['review_id'].describe()

    ● 该列所有的行都不重复吗?

    count 10000

    ● 非重复项的个数是否合理(通常小于20个)?

    上述代码的作用是:

    (2)获取数据;

    上面的代码将数据集中的text列和重复文本duplicate_text进行比较。这看起来有点不可思议,因为将含有10 000个元素的列表和1条文本做比较,对比结果应该是假,不是吗?

    top review

    在进行数据探索之前,我们先对Python数据分析包Pandas的术语做一个简单了解。

    sum(text_is_the_duplicate) # == 2

    图片 14

    下面我们使用以上两个Pandas数据类型开始数据探索!对于定性数据,我们主要关注定类尺度和定序尺度。

    DataFrame本质上是一种二维结构,它和电子表格一样以行列结构存储数据。但是相对于电子表格,DataFrame最重要的优点是它可以处理的数据量远超大多数电子表格。

    # unique 10000

    很多人问我数据科学和数据分析的最大区别是什么。有的人认为两者没有区别,有的人则认为两者千差万别。我认为,尽管两者确实存在很多不同之处,但最大的不同在于数据科学严格遵循结构化、一步一步的操作过程,保证了分析结果的可靠性。

    定性数据的探索技巧

    ● 是否需要对某些列进行数据转换?

    图片 15

    ● user_id:本列是每个提交评价的用户的唯一识别码。和其他唯一识别码一样,本列也属于定类尺度。

    ​图3.2 筛选后的结果

    这是我最喜欢的一步。作为一个创业者,我经常问自己(和他人)很多有意思的问题。我像对待头脑风暴会议一样对待这一步。现在开始写下问题,不要关心回答这些问题所需的数据是否存在。这样做的原因有两个。

    text_is_the_duplicate.head() # shows a few Falses out of the Series

    我们使用的第1个数据集来自点评网站Yelp的公开数据,数据集中所有的身份识别信息已经被删除。首先读取数据,如下所示。

    1.1.5 可视化和分享结果

    Pandas中的筛选

    由于我们处理的大部分数据都是有组织数据,所以DataFrame是Pandas中使用频率仅次于Series的对象。

    text_is_the_duplicate = yelp_raw_data['text'] == duplicate_text

    5个步骤概览

    为什么本书跳过了第(1)、(2)步?

    3 _1QQZuf4zZOyFCvXc0o6Vg

    Series是简化版的DataFrame,它只有一个维度。Series本质上是由数据点组成的列表。DataFrame的每一列都可以被看作一个Series对象。下面用代码进行验证。我们首先从DataFrame中抽取单独一列(通常用中括号),代码如下:

    ● 我们想知道是否需要改变定量数据的数值范围,或者是否需要为定性数据创建哑变量?由于本数据集只有定性数据,所以我们将焦点放在定序和定类范围。

    (3)探索数据;

    yelp_raw_data['text'].describe()

    在本例中,我们无须进行数据转换。

    top fczQCSmaWF78toLEmb0Zsw

    count 10000

    type(text_is_the_duplicate) # it is a Series of Trues and Falses

    首先,我们从宏观上了解以上5个步骤。

    我们可能需要对某些列进行数据转换,当然,这取决于该列的数据层次和定性/定量属性。比如,为了使用统计模型和机器学习模型,数据集中的每一列都需要是数值型的。我们可以使用Python对数据集进行转换。

    ● 查看数据的表头(仅前几行),如图3.1所示。​

    我们使用以下代码验证以上说法。

    看起来我们之前的猜测是对的:某人在同一天,给同一连锁品牌的两家餐馆,撰写了相同的评语。我们接着分析其他列:

    ● top:该列出现次数最多的值。

    问题1:数据是有组织格式的,还是无组织格式的?

    1.1.2 获取数据

    这是我们第一次按照数据科学的5个步骤进行数据探索,不用担心,这肯定不是最后一次。从现在起,每当我们遇到一个新的数据集,都将使用以上数据探索步骤对数据进行转换、分解和标准化。尽管本文介绍的步骤仅仅是一个指引,但为每个数据科学家建立了工作中可遵循的实践标准。这些步骤适用于任何数据集。​

    4 6ozycU1RpktNG2-1BroVtw

    # unique 4174

    yelp_raw_data.shape

    # freq 37

    根据经验,如果数据是无组织格式的,我们需要将其转换为有组织的行列结构。在本书前面的例子中,我们通过对文本中词语计数的方式将其转换为行列结构。

    The location we went to isnew so it isn't in Yelp yet.

    Series

    和其他科学研究一样,这些过程必须被严格执行,否则分析结果将不可靠。再直白一点,对于外行的数据科学家,严格遵循这些过程将能够快速获得准确结果。反之,如果没有清晰的路线图,则分析结果很难得到保证。

    当我们接触新数据集时,有5个基本问题需要回答。请牢记,这些问题并不是数据科学的起点和终点,它们是我们面对新数据集时需要遵循的基本原则。

    yelp_raw_data = pd.read_csv("yelp.csv")

    (1)提出有意思的问题;

    ● freq:该列出现次数最多的值的次数。

    一旦我们弄清楚了数据的组织形式,得到了行列结构的数据集,接下来就需要弄清楚每一行代表的意思。这一步通常不需要花费多少时间,却大有裨益。

    [美] 斯楠·奥兹德米尔(Sinan Ozdemir) 著

    # pandas.core.frame.Dataframe

    type(yelp_raw_data['business_id'])

    定类尺度

    我们先从筛选的机制说起。在Pandas中,基于特定条件对行进行筛选非常简单。对于DataFrame对象,如果想依据某些筛选条件对行进行过滤,只需一行一行检查该行是否满足特定条件即可,同时Pandas将判断结果(真或假)存在一个Series对象中。

    freq 10000

    但为什么eTa5KD-LTgQv6UT1 Zmijmw是出现次数最多的值呢?它只是从10 000个值中随机选择的结果。

    1.1.4 数据建模

    所以,我们首先需要设定一个条件。下面从数据集中提取出现两次的文本:

    你可能想到一个问题,然后自言自语说:“我打赌没有这样的数据可以帮到我们!”然后就将它从问题列表中删除。千万不要这样做,把它留在你的问题列表中!

    我们列出其中几行。

    ● text:本列看起来是用户撰写的评价。对于大部分文本数据,我们将其归为定类尺度。

    # freq 1

    type(yelp_raw_data)

    数据科学的5个必备步骤分别是:

    问题3:每一列代表什么?

    yelp_raw_data.head()

    6 zp713qNhx8d9KCJJnrw1xA

    如果你熟悉R语言,可能认识DataFrame这个词,因为Python中的DataFrame正是从R语言借过来的!

    和business_id类似,数据集由6 403个用户的评价组成,其中评价次数最多的用户评价了38次!

    # count 10000

    这一步涉及统计学和机器学习模型的应用。我们不仅仅选择模型,还通过在模型中植入数学指标,对模型效果进行评价。

    # (10000, 10)

    在本例中,变量yelp_raw_data就是一个DataFrame。

    本文由金莎娱乐发布于互联网,转载请注明出处:数码科学入门的5个技艺,Pandas的大概利用

    关键词:

上一篇:打工皇帝,都不是这些打工皇帝的对手

下一篇:没有了