• 数据分析


    pandas
        安装: pip install pandas
        应用: import pandas as pd
    
        两个数据结构:    
            a. Series:
                定义:Series是一种类似于一维数组的对象,由一组数据和一组与之相关的数据标签(索引)组成
                创建方式:
                    第一种:
                    pd.Series([4,5,6,7,8])
                    执行结果:
                    0    4
                    1    5
                    2    6
                    3    7
                    4    8
                    dtype: int64
                    # 将数组索引以及数组的值打印出来,索引在左,值在右;
                    # 没有为数据指定索引,会自动创建一个0到N-1的整数型索引,取值的时候可以通过索引取值
                    -----------------------------------------------
                    第二种:
                    pd.Series([4,5,6,7,8],index=['a','b','c','d','e'])
                    执行结果:
                    a    4
                    b    5
                    c    6
                    d    7
                    e    8
                    dtype: int64
                    # 自定义索引,index是一个索引列表,里面包含的是字符串,依然可以通过默认索引取值。
                    -----------------------------------------------
                    第三种:
                    pd.Series({"a":1,"b":2})
                    执行结果:
                    a    1
                    b    2
                    dtype: int64
                    # 指定索引
                    -----------------------------------------------
                    第四种:
                    pd.Series(0,index=['a','b','c'])
                    执行结果:
                    a    0
                    b    0
                    c    0
                    dtype: int64
                    # 创建一个值都是0的数组
                1.对缺失值的处理
                    1.dropna:删掉缺失值
                    2.filena:填充缺失数据
                    3.isnull:返回布尔数组,缺失值为true
                    4.notnull: 缺失值为flase
                    
                    # 第一步,创建一个字典,通过Series方式创建一个Series对象
                    st = {"sean":18,"yang":19,"bella":20,"cloud":21}
                    obj = pd.Series(st)
                    obj
                    运行结果:
                    sean     18
                    yang     19
                    bella    20
                    cloud    21
                    dtype: int64
                    ------------------------------------------
                    # 第二步
                    a = {'sean','yang','cloud','rocky'}  # 定义一个索引变量
                    ------------------------------------------
                    #第三步
                    obj1 = pd.Series(st,index=a)
                    obj1  # 将第二步定义的a变量作为索引传入
    
                    # 运行结果:
                    rocky     NaN
                    cloud    21.0
                    sean     18.0
                    yang     19.0
                    dtype: float64
                    # 因为rocky没有出现在st的键中,所以返回的是缺失值
                    通过上面的代码演示,对于缺失值已经有了一个简单的了解,接下来就来看看如何判断缺失值
    
                    Copy
                    1、
                    obj1.isnull()  # 是缺失值返回Ture
                    运行结果:
                    rocky     True
                    cloud    False
                    sean     False
                    yang     False
                    dtype: bool
    
                    2、
                    obj1.notnull()  # 不是缺失值返回Ture
                    运行结果:
                    rocky    False
                    cloud     True
                    sean      True
                    yang      True
                    dtype: bool
    
                    3、过滤缺失值 # 布尔型索引
                    obj1[obj1.notnull()]
                    运行结果:
                    cloud    21.0
                    yang     19.0
                    sean     18.0
                    dtype: float64
                    
                2.series特性:
                    与标量(数字)进行运算:sr * 2
                    srx = sr * 2  # 与标量(数字)进行运算
                    
                    两个Series运算
                    sr * srx  # 两个Series运算
                    
                    布尔值过滤:sr[sr>0]
                    sr[sr>3]  # 布尔索引
                    
                   2.1支持字典的特性:
            
                    # 字典创建Series
                    dic_arr = pd.Series({"A":1,"B":2,"C":3,"D":4,"E":5}
    )  
                    
                    In运算:'a'in sr、for x in sr
                    "A" in dic_arr
                    ------------------------------
                    for i in dic_arr: 
                        print(i)
                        
                    键索引:sr['a'],sr[['a','b','d']]
                    dic_arr[['A','B']]  # 键索引
                    
                    键切片:sr['a':'c']
                    dic_arr['A':'C']  # 键切片
                    
                    其他函数:get('a',default=0)等
                    dic_arr.get("A",default=0)  
                    
                    loc属性 # 以标签解释
                    iloc属性 # 以下标解释
                        
            b. DataFrame:
                1.定义:是一个表格型的数据结构,相当于是一个二维数组,含有一组有序的列。
                     他可以被看做是由Series组成的字典,并且共用一个索引。
                     
                2.创建:
                    第一种:
                        pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
                        # 产生的DataFrame会自动为Series分配所索引,并且列会按照排序的顺序排列
                        运行结果:
                            one    two
                        0    1    4
                        1    2    3
                        2    3    2
                        3    4    1
    
                        > 指定列
                        可以通过columns参数指定顺序排列
                        data = pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
                        pd.DataFrame(data,columns=['one','two'])
    
                    第二种:
                        pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3],index=['b','a','c'])})
                        运行结果:
                           one  two
                        a    1    2
                        b    2    1
                        c    3    3
                
                3.常用属性和方法:
                    1.index 获取行索引
                    2.columns 获取列索引    
                    3.T 转置
                    4.values 获取值索引
                    5.describe 获取快速统计
                    
                       one two
                    a    1    2
                    b    2    1
                    c    3    3
                
                    -----------------------------------------------------------------------------
                    df.index
                    运行结果:
                    Index(['a', 'b', 'c'], dtype='object')
                    ----------------------------------------------------------------------------
                    df.columns
                    运行结果:
                    Index(['one', 'two'], dtype='object')
                    --------------------------------------------------------------------------
                    df.T
                    运行结果:
                        a    b    c
                    one    1    2    3
                    two    2    1    3
                    -------------------------------------------------------------------------
                    df.values
                    运行结果:
                    array([[1, 2],
                           [2, 1],
                           [3, 3]], dtype=int64)
                    ------------------------------------------------------------------------
                    df.describe()
                    运行结果:
                    one    two
                    count    3.0    3.0       #数据统计
                    mean    2.0    2.0          #平均值
                    std    1.0    1.0              #标准差
                    min    1.0    1.0
                    25%    1.5    1.5           #四分之一均值
                    50%    2.0    2.0
                    75%    2.5    2.5
                    max    3.0    3.0
        
                4.索引切片
                    
                    loc属性: 解释为标签
                    iloc属性:解释为下标
                    data.loc[:10,"open":"low"]  # 用标签取值
                    data.iloc[:10,1:5]  # 用下标取值
                        注:
                            DataFrame有行索引和列索引。
                            DataFrame同样可以通过标签和位置两种方法进行索引和切片            
                            
                5.时间处理对象
    
                        import dateutil
                        dateutil.parser.parse("2019 Jan 2nd")  # 这中间的时间格式一定要是英文格式
                        >datetime.datetime(2019, 1, 2, 0, 0)
        
                        pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
    
                        运行结果:
                        DatetimeIndex(['2018-03-01', '2019-02-03', '2019-08-12'], dtype='datetime64[ns]', freq=None)  # 产生一个DatetimeIndex对象
    
                        # 转换时间索引
                        ind = pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
                        sr = pd.Series([1,2,3],index=ind)
                        sr
                        运行结果:
                        2018-03-01    1
                        2019-02-03    2
                        2019-08-12    3
                        dtype: int64
                        通过以上方式就可以将索引转换为时间
    
                        补充:
                        pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019']).to_pydatetime()
                        运行结果:
                        array([datetime.datetime(2018, 3, 1, 0, 0),
                               datetime.datetime(2019, 2, 3, 0, 0),
                               datetime.datetime(2019, 8, 12, 0, 0)], dtype=object)
                        # 通过to_pydatetime()方法将其转换为array数组
                            
                    产生时间对象数组:data_range
                        start 开始时间
                        end 结束时间
                        periods 时间长度
                        freq 时间频率,默认为'D',可选H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…
    
                        pd.date_range("2019-1-1","2019-2-2")
                        运行结果:
                        DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
                                       '2019-01-05', '2019-01-06', '2019-01-07', '2019-01-08',
                                       '2019-01-09', '2019-01-10', '2019-01-11', '2019-01-12',
                                       '2019-01-13', '2019-01-14', '2019-01-15', '2019-01-16',
                                       '2019-01-17', '2019-01-18', '2019-01-19', '2019-01-20',
                                       '2019-01-21', '2019-01-22', '2019-01-23', '2019-01-24',
                                       '2019-01-25', '2019-01-26', '2019-01-27', '2019-01-28',
                                       '2019-01-29', '2019-01-30', '2019-01-31', '2019-02-01',
                                       '2019-02-02'],
                                      dtype='datetime64[ns]', freq='D')
                        时间序列
    
                        时间序列就是以时间对象为索引的Series或DataFrame。datetime对象作为索引时是存储在DatetimeIndex对象中的。
    
                        # 转换时间索引
                        dt = pd.date_range("2019-01-01","2019-02-02")
                        a = pd.DataFrame({"num":pd.Series(random.randint(-100,100) for _ in range(30)),"date":dt})
    
                        # 先生成一个带有时间数据的DataFrame数组
                        a.index = pd.to_datetime(a["date"])
                        
                        # 再通过index修改索引
                        特殊功能:
                        传入“年”或“年月”作为切片方式
                        传入日期范围作为切片方式
                        丰富的函数支持:resample(), strftime(), ……
                        批量转换为datetime对象:to_pydatetime()
                        a.resample("3D").mean()  # 计算每三天的均值
                        a.resample("3D").sum()  #  计算每三天的和
                            
                6.数据分组与聚合
                    apply: GroupBy当中自由度最高的方法,
                    用法:它会将待处理的对象拆分为多个片段,然后各个片段分别调用传入的函数,最后将它们组合到一起。
                    df.apply(
                    ['func', 'axis=0', 'broadcast=None', 'raw=False', 'reduce=None', 'result_type=None', 'args=()', '**kwds']
                            )
                    func:传入一个自定义函数
                    axis:函数传入参数当axis=1就会把一行数据作为Series的数据
                    a.分组(GroupBY机制)
                    
                        df = pd.DataFrame({'key1':['x','x','y','y','x',                               
                                    'key2':['one','two','one',',two','one'],
                                    'data1':np.random.randn(5),
                                    'data2':np.random.randn(5)})
                        df
                                                   
                        >     key1    key2    data1    data2
                        0    x    one    0.951762    1.632336
                        1    x    two    -0.369843    0.602261
                        2    y    one    1.512005    1.331759
                        3    y    two    1.383214    1.025692
                        4    x    one    -0.475737    -1.182826
                        访问data1,并根据key1调用groupby:
    
                        f1 = df['data1'].groupby(df['key1']).groups  #属性
                        f1
    
                        > <pandas.core.groupby.groupby.SeriesGroupBy object at 0x00000275906596D8>
                        上述运行是没有进行任何计算的,接下来,就可以调用groupby进行任何计算
    
                        f1.mean()  # 调用mean函数求出平均值
                        > key1
                            x    0.106183
                            y    2.895220
                            Name: data1, dtype: float64
                        以上数据经过分组键(一个Series数组)进行了聚合,产生了一个新的Series,索引就是key1列中的唯一值。这些索引的名称就为key1。接下来就尝试一次将多个数组的列表传进来
    
                        f2 = df['data1'].groupby([df['key1'],df['key2']])
                        f2.mean()
                        > key1  key2
                            x     one     0.083878
                                  two     0.872437
                            y     one    -0.665888
                                  two    -0.144310
                            Name: data1, dtype: float64
    
                        传入多个数据之后会发现,得到的数据具有一个层次化的索引,key1对应的xy;key2对应的one	wo.
    
                        f2.mean().unstack()  # 通过unstack方法就可以让索引不堆叠在一起了
    
                        > key2    one        two
                        key1        
                        x    0.083878    0.872437
                        y    -0.665888    -0.144310
    
                        补充:
    
                            1、分组键可以是任意长度的数组
                            2、分组时,对于不是数组数据的列会从结果中排除,例如key1、key2这样的列
                            3、GroupBy的size方法,返回一个含有分组大小的Series
                        
                        # 以上面的f2测试
                        f2.size()
                        > key1  key2
                        x     one     2
                              two     1
                        y     one     1
                              two     1
                        Name: data1, dtype: int64
                        
                    
                        
                    b.聚合
                        um    非NA值的和
                        median    非NA值的算术中位数
                        std、var    无偏(分母为n-1)标准差和方差
                        prod    非NA值的积
                        first、last    第一个和最后一个非NA值
                    
                        
                    常用方法:
                        mean(axis=0,skipna=False)
                        sum(axis=1)
                        sort_index(axis, …, ascending) # 按行或列索引排序
                        sort_values(by, axis, ascending) # 按值排序
                        apply(func, axis=0) # 将自定义函数应用在各行或者各列上,func可返回标量或者Series
                        applymap(func) # 将函数应用在DataFrame各个元素上
                        map(func) # 将函数应用在Series各个元素上   
  • 相关阅读:
    指针和数组的关系
    深入学习数组
    const关键字与指针
    野指针是什么
    指针带来的一些符号的理解
    指针的本质
    内存管理之堆
    内存管理之栈
    元类
    断点调式和面向对象进阶
  • 原文地址:https://www.cnblogs.com/wyf20190411-/p/13906627.html
Copyright © 2020-2023  润新知