• pandas之基础操作


    一、两种核心数据结构的创建

      

    '''
        pandas基础操作
    '''
    import pandas as pd
    import numpy as np
    
    # 创建Series类型的数据
    p1 = pd.Series([90, 86, 70], index=['leo', 'kate', 'john'])
    print(p1)
    dict = {'leo': 90, 'kate': 86, 'john': 70}
    p2 = pd.Series(dict)
    print(p2)
    print('==========================')
    p3 = pd.Series(np.random.randn(5), index=list('ABCDE'))
    print(p3)
    p4 = pd.Series(np.random.normal(size=(5,)), index=list('ABCDE'))
    print(p4)
    p5 = pd.Series(6)
    print(p5)
    
    # 创建DataFrame类型的数据
    data = [
        ['张三', 29, 69],
        ['王五', 20, 86],
        ['李四', 25, 88],
    ]
    q = pd.DataFrame(data, index=[1, 2, 3], columns=['姓名', '年龄', '分数'])
    print(q)
    
    # 创建时间
    date = pd.date_range('20100101', periods=6)
    print(date)
    df1 = pd.DataFrame(np.random.randn(6, 4), index=date, columns=list('abcd'))
    print(df1)
    
    df2 = pd.DataFrame(np.random.normal(size=(6, 4)), index=date, columns=['a', 'b', 'c', 'd'])
    print(df2)
    
    
    
    输出结果:
    
    leo     90
    kate    86
    john    70
    dtype: int64
    leo     90
    kate    86
    john    70
    dtype: int64
    ==========================
    A    1.159360
    B   -0.666339
    C    0.308588
    D   -0.506679
    E    1.512920
    dtype: float64
    A   -0.490887
    B    1.112884
    C    2.213500
    D   -1.235730
    E   -0.512336
    dtype: float64
    0    6
    dtype: int64
       姓名  年龄  分数
    1  张三  29  69
    2  王五  20  86
    3  李四  25  88
    DatetimeIndex(['2010-01-01', '2010-01-02', '2010-01-03', '2010-01-04',
                   '2010-01-05', '2010-01-06'],
                  dtype='datetime64[ns]', freq='D')
                       a         b         c         d
    2010-01-01 -0.823523 -1.409990  0.226064  1.179078
    2010-01-02 -1.038028 -0.471260  1.400937  1.307517
    2010-01-03  0.020108 -0.965482  0.179132 -0.048759
    2010-01-04 -0.401916 -0.354500  1.428424 -0.561267
    2010-01-05 -1.072954  0.601991 -0.209088 -1.012752
    2010-01-06 -0.362519  0.068684  0.429000  0.483278
                       a         b         c         d
    2010-01-01  0.190991  0.070639  2.418837 -0.697829
    2010-01-02  0.564987 -0.793603 -0.140782 -1.035729
    2010-01-03  0.082700  0.250710  0.504365 -0.801025
    2010-01-04  0.769330 -1.462820  1.213319 -1.516593
    2010-01-05  0.940503  0.634657 -0.952838  1.675215
    2010-01-06  0.520664  0.795519 -0.346242 -0.543367

    二、数据结构属性

      

    '''
        pandas中核心数据结构的基本属性
            1.Series数据结构
            2.DataFrame数据结构
    '''
    import pandas as pd
    
    # Series基础属性
    s1 = pd.Series([90, 86, 70], index=['leo', 'kate', 'john'])
    print(s1)
    # 打印元素
    print(s1.values)
    #打印索引
    print(s1.index)
    # 打印类型
    print(s1.dtype)
    # 打印维度
    print(s1.ndim)
    # 打印数据形状
    print(s1.shape)
    
    输出结果:
    leo     90
    kate    86
    john    70
    dtype: int64
    [90 86 70]
    Index(['leo', 'kate', 'john'], dtype='object')
    int64
    1
    (3,)

    三、数据查找

      

    '''
        数据的增删改查
            查找:
                1.对Series数据查找,主要通过索引:
                    1>通过index对应的标签查找
                    2>通过绝对位置查看,可以是绝对位置的数字、列表、或者表达式等
    
                2.对DataFrame
                    1>对单列数据的访问(两种方式):DataFrame的单列数据为一个Series。根据DataFrame的定义可以 知晓DataFrame是一个带有标签的二维数组,
                                            每个标签相当每一列的列名。df.a df['a']
                    2>对多列数据访问:访问DataFrame多列数据可以将多个列索引名称视为一个列表,df[['a','b']]
                    3>对行数据访问:
                        3.1 如果只是需要访问DataFrame某几行数据的实现方式则采用数组的选取方式,使用“:”。
                        3.2 head和tail也可以得到多行数据,但是用这两种方法得到的数据都是从开始或者末尾获取的连续数据。
                            默认参数为访问5行,只要在方法后方的“()”中填入访问行数即可实现目标行数的查看。
    
                    4>高级查看方法---loc,iloc方法(速度快)DataFrame常用查找方法
                        4.1 loc方法:是针对DataFrame索引名称的切片方法,如果传入的不是索引名称,那么切片操作将无法执行。
                                    利用loc方法,能够实现所有单层索引切片操作。loc方法使用方法如下:
                                        DataFrame.loc[行索引名称或条件, 列索引名称]
                        4.2 iloc方法:和loc区别是iloc接收的必须是行索引和列索引的位置。iloc方法的使用方法如下:
                                        DataFrame.iloc[行索引位置, 列索引位置]
                        4.3 两种方法使用方式:
                            1>使用loc方法和iloc实现多列切片,其原理的通俗解释就是将多列的列名或者位置作为一个列表或者数据传入。
                                使用loc,iloc方法可以取出DataFrame中的任意数据。
                            2>loc内部还可以传入表达式,结果会返回满足表达式的所有值。
                            3>loc更加灵活多变,代码的可读性更高,iloc的代码简洁,但可读性不高。
                                具体在数据分析工作中使用哪一种方法,根据情况而定,大多数时候建议使用loc方法。
                            4>在loc使用的时候内部传入的行索引名称如果为一个区间,则前后均为闭区间;
                                iloc方法使用时内部传入的行索引位置或列索引位置为区间时,则为前闭后开区间。
                    5>ix方法:切片方法
                        5.1 ix方法更像是loc和iloc两种切片方法的融合。ix方法在使用时既可以接收索引名称也可以接收索引位置。
                            其使用方法如下:
                                DataFrame.ix[行索引的名称或位置或者条件,列索引名称或位置]
                        5.2 使用ix方法时有个注意事项,第一条,当索引名称和位置存在部分重叠时,ix默认优先识别名称。
                        5.3 控制ix方法需要注意以下几点:
                            1>使用列索引名称,而非列索引位置。主要用来保证代码可读性.
                            2>使用列索引位置时,需要注解。同样保证代码可读性.
                            3>除此之外ix方法还有一个缺点,就是在面对数据量巨大的任务的时候,其效率会低于loc和iloc方法,
                                所以在日常的数据分析工作中建议使用loc和iloc方法来执行切片操作.
    
    
    '''
    import pandas as pd
    import numpy as np
    import warnings
    
    warnings.filterwarnings('ignore')
    
    # Serise查找
    s1 = pd.Series([90, 86, 70], index=['leo', 'kate', 'john'])
    print(s1)
    # 绝对位置查找
    print(s1[0])
    # 通过标签查找
    print(s1['john'])
    # 通过列表查找
    print(s1[['john', 'kate']])
    print(s1[[0, 2]])
    # 通过表达式查找
    print(s1[s1 > 80])
    print('==============================')
    
    date = pd.date_range('20100101', periods=6)
    df1 = pd.DataFrame(np.random.randn(6, 4), index=date, columns=list('abcd'))
    print(df1)
    
    # DataFrame数据的单列查找
    print(df1.a)
    print(df1['a'])
    
    # DataFrame数据的多列查找
    print(df1[['a', 'c']])
    
    # 使用‘:’读取行数据,可以是单行或者多行
    print(df1[3:4])
    print(df1[:4])
    # 使用head()函数读取前多少行,默认前五行
    print(df1.head(3))
    
    # 使用tail()函数读取后多少行,默认后五行
    print(df1.tail(3))
    
    # 使用loc[,]方法查找
    print(df1.loc['2010-01-01':'2010-01-03', 'a':'c'])
    print(df1.loc['2010-01-01':'2010-01-03', ['a', 'd']])
    print(df1.loc[df1.index < '2010-01-04'])
    print(df1.loc[df1.index < '20100104'])
    # 使用iloc[,]方法查找
    print(df1.iloc[0:3, [0, 2, 3]])
    print(df1.iloc[[2, 4, 5], 2:])
    # 使用ix[,]方法查找
    print(df1.ix['2010-01-01': '2010-01-04', 0:3])
    
    
    
    
    
    
    
    输出结果:
    leo     90
    kate    86
    john    70
    dtype: int64
    90
    70
    john    70
    kate    86
    dtype: int64
    leo     90
    john    70
    dtype: int64
    leo     90
    kate    86
    dtype: int64
    ==============================
                       a         b         c         d
    2010-01-01 -1.165119  0.678715 -0.485707  1.027487
    2010-01-02 -0.044734 -1.702172  0.567219  0.091994
    2010-01-03 -0.294266 -0.183854  0.380807  0.196074
    2010-01-04 -0.305703 -2.452826  0.833772  0.284876
    2010-01-05  0.377458 -0.859994  0.186893  0.844783
    2010-01-06  1.105398  0.434033  0.141374 -1.101191
    2010-01-01   -1.165119
    2010-01-02   -0.044734
    2010-01-03   -0.294266
    2010-01-04   -0.305703
    2010-01-05    0.377458
    2010-01-06    1.105398
    Freq: D, Name: a, dtype: float64
    2010-01-01   -1.165119
    2010-01-02   -0.044734
    2010-01-03   -0.294266
    2010-01-04   -0.305703
    2010-01-05    0.377458
    2010-01-06    1.105398
    Freq: D, Name: a, dtype: float64
                       a         c
    2010-01-01 -1.165119 -0.485707
    2010-01-02 -0.044734  0.567219
    2010-01-03 -0.294266  0.380807
    2010-01-04 -0.305703  0.833772
    2010-01-05  0.377458  0.186893
    2010-01-06  1.105398  0.141374
                       a         b         c         d
    2010-01-04 -0.305703 -2.452826  0.833772  0.284876
                       a         b         c         d
    2010-01-01 -1.165119  0.678715 -0.485707  1.027487
    2010-01-02 -0.044734 -1.702172  0.567219  0.091994
    2010-01-03 -0.294266 -0.183854  0.380807  0.196074
    2010-01-04 -0.305703 -2.452826  0.833772  0.284876
                       a         b         c         d
    2010-01-01 -1.165119  0.678715 -0.485707  1.027487
    2010-01-02 -0.044734 -1.702172  0.567219  0.091994
    2010-01-03 -0.294266 -0.183854  0.380807  0.196074
                       a         b         c         d
    2010-01-04 -0.305703 -2.452826  0.833772  0.284876
    2010-01-05  0.377458 -0.859994  0.186893  0.844783
    2010-01-06  1.105398  0.434033  0.141374 -1.101191
                       a         b         c
    2010-01-01 -1.165119  0.678715 -0.485707
    2010-01-02 -0.044734 -1.702172  0.567219
    2010-01-03 -0.294266 -0.183854  0.380807
                       a         d
    2010-01-01 -1.165119  1.027487
    2010-01-02 -0.044734  0.091994
    2010-01-03 -0.294266  0.196074
                       a         b         c         d
    2010-01-01 -1.165119  0.678715 -0.485707  1.027487
    2010-01-02 -0.044734 -1.702172  0.567219  0.091994
    2010-01-03 -0.294266 -0.183854  0.380807  0.196074
                       a         b         c         d
    2010-01-01 -1.165119  0.678715 -0.485707  1.027487
    2010-01-02 -0.044734 -1.702172  0.567219  0.091994
    2010-01-03 -0.294266 -0.183854  0.380807  0.196074
                       a         c         d
    2010-01-01 -1.165119 -0.485707  1.027487
    2010-01-02 -0.044734  0.567219  0.091994
    2010-01-03 -0.294266  0.380807  0.196074
                       c         d
    2010-01-03  0.380807  0.196074
    2010-01-05  0.186893  0.844783
    2010-01-06  0.141374 -1.101191
                       a         b         c
    2010-01-01 -1.165119  0.678715 -0.485707
    2010-01-02 -0.044734 -1.702172  0.567219
    2010-01-03 -0.294266 -0.183854  0.380807
    2010-01-04 -0.305703 -2.452826  0.833772
  • 相关阅读:
    Python增删改查文件
    Python实现验证用户信息后跳转网页的功能
    Python文件操作
    python集合操作
    字典的用法
    二分查找
    git命令记录
    JavaScript高级程序设计window对象学习记录
    JS模块化简介(读书笔记)
    Webpack代码分割 + 懒加载
  • 原文地址:https://www.cnblogs.com/yuxiangyang/p/11181167.html
Copyright © 2020-2023  润新知