精华内容
下载资源
问答
  • Pandas数据取值与选择
    2022-03-19 12:10:08

    第1关:Series数据选择

    本关任务:根据相关知识,得到目标Series对象,具体要求请查看编程要求。

    import pandas as pd
    import numpy as np
    
    arr = input()
    dates = pd.date_range('20190101', periods=25) # 生成时间序列
    df = pd.Series(eval
    更多相关内容
  • 1、什么是Pandas当大家谈论到数据分析时,提及最多的语言就是Python和SQL,而Python之所以适合做数据分析,就是因为他有很多强大的第三方库来协助,pandas就是其中之一,它是基于Numpy构建的,正因pandas的出现,让...

    1、什么是Pandas

    当大家谈论到数据分析时,提及最多的语言就是Python和SQL,而Python之所以适合做数据分析,就是因为他有很多强大的第三方库来协助,pandas就是其中之一,它是基于Numpy构建的,正因pandas的出现,让Python语言也成为使用最广泛而且强大的数据分析环境之一。如果说没有pandas的出现,目前的金融数据分析领域还应该是R语言的天下。

    2、Pandas能干什么

    Pandas的主要功能:

    具备对应其功能的数据结构DataFrame,Series集成时间序列功能提供丰富的数学运算和操作灵活处理缺失数据.....

    以上就是pandas能完成的一些基础操作,当然并不完全,下面就来看看pandas到底是怎么用的。

    3、怎么用Pandas

    安装方法:

    pip install pandas

    引用方法:

    import pandas as pd

    3.1、Series

    Series是一种类似于一维数组的对象,由一组数据和一组与之相关的数据标签(索引)组成。在数据分析的过程中非常常用。

    3.1.1、创建方法

    第一种:

    pd.Series([4,5,6,7,8])

    执行结果:

    0    4

    1    5

    2    6

    3    7

    4    8

    dtype: int64

    # 将数组索引以及数组的值打印出来,索引在左,值在右,由于没有为数据指定索引,于是会自动创建一个0到N-1(N为数据的长度)的整数型索引,取值的时候可以通过索引取值,跟之前学过的数组和列表一样

    -----------------------------------------------

    第二种:

    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的数组

    -----------------------------------------------

    对于Series,其实我们可以认为它是一个长度固定且有序的字典,因为它的索引和数据是按位置进行匹配的,像我们会使用字典的上下文,就肯定也会使用Series

    3.1.2、缺失数据

    dropna() # 过滤掉值为NaN的行fill() # 填充缺失数据isnull() # 返回布尔数组,缺失值对应为Truenotnull() # 返回布尔数组,缺失值对应为False

    # 第一步,创建一个字典,通过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的键中,所以返回的是缺失值

    通过上面的代码演示,对于缺失值已经有了一个简单的了解,接下来就来看看如何判断缺失值

    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

    3.1.3、Series特性

    import numpy as np

    import pandas as pd

    从ndarray创建Series:Series(arr)

    arr = np.arange(10)

    sr = pd.Series(arr)  # ndarray创建Series

    与标量(数字)进行运算:sr * 2

    srx = sr * 2  # 与标量(数字)进行运算

    两个Series运算

    sr * srx  # 两个Series运算

    布尔值过滤:sr[sr>0]

    sr[sr>3]  # 布尔值过滤

    统计函数:mean()、sum()、cumsum()

    # 统计函数

    sr.mean()

    sr.sum()

    sr.cumsum()

    3.1.4、支持字典的特性

    从字典创建Series:Series(dic),

    dic = {"A":1,"B":2,"C":3,"D":4,"E":5}

    # 字典创建Series

    dic_arr = pd.Series(dic)

    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)

    3.1.5、整数索引

    pandas当中的整数索引对象可能会让初次接触它的人很懵逼,接下来通过代码演示:

    sr = pd.Series(np.arange(10))

    sr1 = sr[3:].copy()

    sr1

    运行结果:

    3    3

    4    4

    5    5

    6    6

    7    7

    8    8

    9    9

    dtype: int32

    # 到这里会发现很正常,一点问题都没有,可是当使用整数索引取值的时候就会出现问题了。因为在pandas当中使用整数索引取值是优先以标签解释的,而不是下标

    sr1[1]

    解决方法:

    loc属性 # 以标签解释iloc属性 # 以下标解释

    sr1.iloc[1]  # 以下标解释

    sr1.loc[3]  # 以标签解释

    3.1.6、Series数据对齐

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

    sr1 = pd.Series([12,23,34], index=['c','a','d'])

    sr2 = pd.Series([11,20,10], index=['d','c','a',])

    sr1 + sr2

    运行结果:

    a    33

    c    32

    d    45

    dtype: int64

    # 可以通过这种索引对齐直接将两个Series对象进行运算

    sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])

    sr1 + sr3

    运行结果:

    a    33.0

    b     NaN

    c    32.0

    d    45.0

    dtype: float64

    # sr1 和 sr3的索引不一致,所以最终的运行会发现b索引对应的值无法运算,就返回了NaN,一个缺失值

    将两个Series对象相加时将缺失值设为0:

    sr1 = pd.Series([12,23,34], index=['c','a','d'])

    sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])

    sr1.add(sr3,fill_value=0)

    运行结果:

    a    33.0

    b    14.0

    c    32.0

    d    45.0

    dtype: float64

    # 将缺失值设为0,所以最后算出来b索引对应的结果为14

    灵活的算术方法:add,sub,div,mul

    到这里可能就会说了pandas就这么简单吗,那我们接下来一起看看这个二维数组DataFraeme

    3.2、DataFrame

    DataFrame是一个表格型的数据结构,相当于是一个二维数组,含有一组有序的列。他可以被看做是由Series组成的字典,并且共用一个索引。接下来就一起来见识见识DataFrame数组的厉害吧!!!

    3.2.1、创建方式

    创建一个DataFrame数组可以有多种方式,其中最为常用的方式就是利用包含等长度列表或Numpy数组的字典来形成DataFrame:

    第一种:

    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'])

    # 打印结果会按照columns参数指定顺序

    第二种:

    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.2.2、查看数据

    常用属性和方法:

    index 获取行索引columns 获取列索引T 转置values 获取值索引describe 获取快速统计

    one    two

    a   1   2

    b   2   1

    c   3   3

    # 这样一个数组df

    ---------------------------------------------------------------------------

    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   # 最大值

    3.2.3、索引和切片

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

    DataFrame使用索引切片:

    方法1:两个中括号,无论是先取行还是先取列都可以。

    import tushare as ts

    data = ts.get_k_data("000001")

    data['open'][:10]  # 先取列再取行

    data[:10]['open']  # 先取行再取列

    方法2(推荐):使用loc/iloc属性,一个中括号,逗号隔开,先取行再取列。

    loc属性:解释为标签iloc属性:解释为下标

    data.loc[:10,"open":"low"]  # 用标签取值

    data.iloc[:10,1:5]  # 用下标取值

    向DataFrame对象中写入值时只使用方法2行/列索引部分可以是常规索引、切片、布尔值索引、花式索引任意搭配。(注意:两部分都是花式索引时结果可能与预料的不同)

    3.3、时间对象处理

    处理时间对象可能是我们在进行数据分析的过程当中最常见的,我们会遇到各种格式的时间序列,也需要处理各种格式的时间序列,但是一定不能对这些数据懵逼,我们需要找到最合适的招式来处理这些时间。接下来就一起来看吧!!!

    3.3.1、时间序列类型

    时间戳:特定时刻固定时期:如2019年1月时间间隔:起始时间-结束时间

    3.3.2、Python库:datatime

    date、datetime、timedelta

    import datetime

    # datetime.date()  # date对象

    today = datetime.date.today()  # 获取当天日期,返回date对象

    t1 = datetime.date(2019,4,18) # 设置时间格式为datetime.date

    # datetime.datetime()  # datetime对象

    now = datetime.datetime.now()  # 获取当天日期,返回datetime对象

    t2 = datetime.datetime(2019,4,18) # 设置时间格式为datetime.datetime

    # datetime.timedelta()  # 时间差

    today = datetime.datetime.today()

    yestoday = today - datetime.timedelta(1)  # 以时间做运算

    print(today,yestoday)

    dt.strftime()

    # 将时间格式转换为字符串

    today.strftime("%Y-%m-%d")

    yestoday.strftime("%Y-%m-%d")

    strptime()

    # 将日期字符串转成datetime时间格式,第二个参数由时间格式决定

    datetime.datetime.strptime('2019-04-18','%Y-%m-%d')

    3.3.3、灵活处理时间对象:dateutil包

    dateutil.parser.parse()

    import dateutil

    # 将字符串格式的日期转换为datetime对象

    date = '2019 Jan 2nd'

    t3 = dateutil.parser.parse(date)

    3.3.4、成组处理时间对象:pandas

    pd.to_datetime(['2018-01-01', '2019-02-02'])

    将字符串转换为为时间对象

    from datetime import datetime

    import pandas as pd

    date1 = datetime(2019, 4, 18, 12, 24, 30)

    date2 = '2019-04-18'

    t4 = pd.to_datetime(date1)

    t5 = pd.to_datetime(date2)

    t6 = pd.to_datetime([date1,date2])

    t4,t5,t6  # 转换单个时间数据是返回Timestamp对象,转换多个时间数据返回DatetimeIndex对象

    >

    """

    (Timestamp('2019-04-18 12:24:30'),

    Timestamp('2019-04-18 00:00:00'),

    DatetimeIndex(['2019-04-18 12:24:30', '2019-04-18 00:00:00'], dtype='datetime64[ns]', freq=None))

    """

    将索引设置为时间序列

    ind = pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])

    sr = pd.Series([1,2,3],index=ind)

    # 补充:

    """

    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()方法将其转换为ndarray数组

    """

    3.3.5、产生时间对象数组: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",freq="D")

    > 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')

    3.3.6、时间序列

    时间序列就是以时间对象为索引的Series或DataFrame。datetime对象作为索引时是存储在DatetimeIndex对象中的。

    # 转换时间索引

    dt = pd.date_range("2019-01-01","2019-02-02")

    # 生成一个带有时间数据的DataFrame数组

    a = pd.DataFrame({"num":pd.Series(random.randint(-100,100) for _ in range(30)),"date":dt})

    # 通过index修改索引

    a.index = pd.to_datetime(a["date"])

    特殊功能:

    传入“年”或“年月”作为切片方式传入日期范围作为切片方式丰富的函数支持:resample(), strftime(), ……

    a.resample("3D").mean()  # 计算每三天的均值

    a.resample("3D").sum()  #  计算每三天的和

    ...

    时间序列的处理在数据分析当中非常重要,但是有时候时间的格式不一致又会让人非常烦躁,只要把以上秘籍都学会就可以把时间序列制得服服帖帖。

    3.4、数据分组和聚合

    在数据分析当中,我们有时需要将数据拆分,然后在每一个特定的组里进行运算,这些操作通常也是数据分析工作中的重要环节。分组聚合相对来说也是一个稍微难理解的点,需要各位有一定的功力来学习.

    3.4.1、分组(GroupBY机制)

    pandas对象(无论Series、DataFrame还是其他的什么)当中的数据会根据提供的一个或者多个键被拆分为多组,拆分操作实在对象的特定轴上执行的。就比如DataFrame可以在他的行上或者列上进行分组,然后将一个函数应用到各个分组上并产生一个新的值。最后将所有的执行结果合并到最终的结果对象中。

    分组键可以是多种样式,并且键不一定是完全相同的类型:

    列表或者数组,长度要与待分组的轴一样表示DataFrame某个列名的值。字典或Series,给出待分组轴上的值与分组名之间的对应关系函数,用于处理轴索引或者索引中的各个标签

    后三种只是快捷方式,最终仍然是为了产生一组用于拆分对象的值。

    首先,通过一个很简单的DataFrame数组尝试一下:

    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'])

    f1

    >

    上述运行是没有进行任何计算的,但是我们想要的中间数据已经拿到了,接下来,就可以调用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对应的onetwo.

    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

    到这跟着我上面的步骤一步一步的分析,会发现还是很简单的,但是一定不能干看,还要自己下手练,只有多练才能融汇贯通!!!

    3.4.2、聚合(组内应用某个函数)

    聚合是指任何能够从数组产生标量值的数据转换过程。刚才上面的操作会发现使用GroupBy并不会直接得到一个显性的结果,而是一个中间数据,可以通过执行类似mean、count、min等计算得出结果,常见的还有一些:

    函数名描述sum非NA值的和median非NA值的算术中位数std、var无偏(分母为n-1)标准差和方差prod非NA值的积first、last第一个和最后一个非NA值

    自定义聚合函数

    不仅可以使用这些常用的聚合运算,还可以自己自定义。

    # 使用自定义的聚合函数,需要将其传入aggregate或者agg方法当中

    def peak_to_peak(arr):

    return arr.max() - arr.min()

    f1.aggregate(peak_to_peak)

    运行结果:

    key1

    x    3.378482

    y    1.951752

    Name: data1, dtype: float64

    多函数聚合:

    f1.agg(['mean','std'])

    运行结果:

    mean    std

    key1

    x   -0.856065   0.554386

    y   -0.412916   0.214939

    最终得到的列就会以相应的函数命名生成一个DataFrame数组

    以上我们是可以通过agg或者是aggregate来实现多函数聚合以及自定义聚合函数,但是一定要注意agg方法只能进行聚合操作,进行其他例如:排序,这些方法是会报错的。agg返回的是数据的标量,所以有些时候并不适合使用agg,这就要看我们接下来的操作了。

    3.4.3、apply

    GroupBy当中自由度最高的方法就是apply,它会将待处理的对象拆分为多个片段,然后各个片段分别调用传入的函数,最后将它们组合到一起。

    df.apply(

    ['func', 'axis=0', 'broadcast=None', 'raw=False', 'reduce=None', 'result_type=None', 'args=()', '**kwds']

    func:传入一个自定义函数axis:函数传入参数当axis=1就会把一行数据作为Series的数据

    # 分析欧洲杯和欧洲冠军联赛决赛名单

    import pandas as pd

    url="https://en.wikipedia.org/wiki/List_of_European_Cup_and_UEFA_Champions_League_finals"

    eu_champions=pd.read_html(url)  # 获取数据

    a1 = eu_champions[2]    # 取出决赛名单

    a1.columns = a1.loc[0]  # 使用第一行的数据替换默认的横向索引

    a1.drop(0,inplace=True)  # 将第一行的数据删除

    a1.drop('#',axis=1,inplace=True)  # 将以#为列名的那一列删除

    a1.columns=['Season', 'Nation', 'Winners', 'Score', 'Runners_up', 'Runners_up_Nation', 'Venue','Attendance']  # 设置列名

    a1.tail()  # 查看后五行数据

    a1.drop([64,65],inplace=True)  # 删除其中的缺失行以及无用行

    a1

    运行结果:

    现在想根据分组选出Attendance列中值最高的三个。

    # 先自定义一个函数

    def top(df,n=3,column='Attendance'):

    return df.sort_values(by=column)[-n:]

    top(a1,n=3)

    运行结果:

    接下来,就对a1分组并且使用apply调用该函数:

    a1.groupby('Nation').apply(top)

    运行之后会发现,我们通过这个操作将每个国家各个年份时段出席的人数的前三名进行了一个提取。

    以上top函数是在DataFrame的各个片段上调用,然后结果又通过pandas.concat组装到一起,并且以分组名称进行了标记。

    以上只是基本用法,apply的强大之处就在于传入函数能做什么都由自己说了算,它只是返回一个pandas对象或者标量值就行

    3.5、其他常用方法

    pandas常用方法(适用Series和DataFrame)

    mean(axis=0,skipna=False)sum(axis=1)sort_index(axis, …, ascending) # 按行或列索引排序sort_values(by, axis, ascending) # 按值排序apply(func, axis=0) # 将自定义函数应用在各行或者各列上,func可返回标量或者Seriesapplymap(func) # 将函数应用在DataFrame各个元素上map(func) # 将函数应用在Series各个元素上

    展开全文
  • demo.py(Series取值,切片): import pandas as pd t1 = pd.Series([13, 23, 33, 43, 53], index=["a", "b", "c", "d", "e"]) print(t1) ''' a 13 b 23 c ...

     

    demo.py(Series取值,切片):

    import pandas as pd
    
    
    t1 = pd.Series([13, 23, 33, 43, 53], index=["a", "b", "c", "d", "e"])
    print(t1)
    '''
    a    13
    b    23
    c    33
    d    43
    e    53
    dtype: int64
    '''
    
    # 通过索引直接取值
    print(t1["d"])  # 43
    # 通过位置取值(从0开始)
    print(t1[3])  # 43
    
    
    # 切片
    # 取位置连续的值
    print(t1[1:4])  # 也可以指定步长
    '''
    b    23
    c    33
    d    43
    dtype: int64
    '''
    
    # 取位置不连续的值
    print(t1[[1,3]])
    '''
    b    23
    d    43
    dtype: int64
    '''
    # 也可以通过索引取多个值
    print(t1[["b","d","w"]])  # 如果指定的索引不存在,那么对应值就返回NaN(float类型)
    '''
    b    23.0
    d    43.0
    w     NaN
    dtype: float64
    '''
    

    demo.py(Series的index和values属性):

    import pandas as pd
    
    
    t1 = pd.Series([13, 23, 33, 43, 53], index=["a", "b", "c", "d", "e"])
    print(t1)
    '''
    a    13
    b    23
    c    33
    d    43
    e    53
    dtype: int64
    '''
    
    print(type(t1.index))  # <class 'pandas.core.indexes.base.Index'>
    print(t1.index)   # Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
    print(len(t1.index))  # 5  有长度 可以遍历迭代
    # 可以强制转换成list类型
    print(list(t1.index))  # ['a', 'b', 'c', 'd', 'e']
    
    
    print(type(t1.values))  # <class 'numpy.ndarray'>
    print(t1.values)   # [13 23 33 43 53]
    # ndarray的很多方法都可以运用到Series类型。 例如:argmax()获取最大值;clip()裁剪等。
    
    # Series对象本质上由两个数组构成,一个构成索引index,一个构成对象的值values
    
    

    demo.py(Series的布尔索引):

    import pandas as pd
    
    
    t1 = pd.Series([13, 23, 33, 43, 53], index=["a", "b", "c", "d", "e"])
    print(t1)
    '''
    a    13
    b    23
    c    33
    d    43
    e    53
    dtype: int64
    '''
    
    # Series类型也支持bool索引。
    print(t1[t1>30])
    '''
    c    33
    d    43
    e    53
    dtype: int64
    '''
    
    t1[t1>30] = 0
    print(t1)
    '''
    a    13
    b    23
    c     0
    d     0
    e     0
    dtype: int64
    '''
    

     

     

    展开全文
  • pandas 介绍之二-取值和选择作者:everyang.net 老Lin前言:上一篇介绍了pandas三种基本结构的创建,index是一个不可变数组和数据集;series是一个系列,可由列表、字典、np结构创建,也可以看做是Df结构的子集;而...

    pandas 介绍之二-取值和选择

    作者:everyang.net 老Lin

    前言:上一篇介绍了pandas三种基本结构的创建,index是一个不可变数组和数据集;series是一个系列,可由列表、字典、np结构创建,也可以看做是Df结构的子集;而dataFrame是多维数组,可由多个字典或np多维数组构建。基本数据结构创建后,就需要调用。如果数据比如交易量达到百万级,要找出其中某个值是一个基础,但也是一个关键的问题。所以我们讨论的,都是在海量数据背景下,但用简单的数据更好实验,因为原理相同。

    一、系列series对象的选择方法

    1、象字典一样取值

    import pandas as pd

    codeDict = {'beijing':'010','shanghai':'021','wuhan':'027','nanjing':'025'}

    codePds = pd.Series(codeDict)

    print(codePds['wuhan']) # out 021,类似字典

    print('nanjing' in codePds.keys()) # out True,类似字典key判定

    print('024' in codePds) # out False, 这里不能带values

    print(list(codePds.items())) # 直接打印items不行,需要转换为列表

    2、筛选和查询,用布尔掩码

    假定我们有一个100万条数据量,需要找出其中大于0.5555-0.5556的索引。

    import numpy as np

    import pandas as pd

    x = np.random.random(100000) # 生成一个1M随机数npArray数组

    y = pd.Series(x) # 根据np数组创建pd Series系列

    print(y[(y>0.5555) & (y<0.5556)].index) # 掩码操作,将布尔掩码作为子集

    输出:Int64 Index([4221, 27470, 29224, 59492, 71030, 83955, 86168], dtype=’int64′)

    3、切片和索引

    首先,Series的取值可以按照python标准的切片操作。比如,按上例,y[0],y[0:10]

    其次,pandas提供索引器indexer可以作为取值方法,一种索引器是loc属性,例如y.loc[1];一种索引器是iloc,如y.iloc[1],可以试验一下看,看看两种有什么区别?

    二、数据集DataFrame对象的选择方法

    先建立一个DataFrame。我们从网上收集公开发布的2016年财政收入和增长率(仅为试验数据,不对准确性负责),形成两个系列,再建立为一个DF。如下:

    receipts = pd.Series({'GuangDong':10390.33, 'JiangSu':8121.23, 'ShangHai':6406.13, 'ShanDong':5860.20, 'ZheJiang':5301.81, 'BeiJing':5031.3})

    percents = pd.Series({'GuangDong':10.3, 'JiangSu':5.0, 'ShangHai':16.1, 'ShanDong':8.5, 'ZheJiang':9.8, 'BeiJing':7.5})

    sDf = pd.DataFrame({'receipts':receipts, 'inc pencent':percents})

    print(sDf)

    # inc pencent receipts

    # BeiJing 7.5 5031.30

    # GuangDong 10.3 10390.33

    # JiangSu 5.0 8121.23

    # ShanDong 8.5 5860.20

    # ShangHai 16.1 6406.13

    # ZheJiang 9.8 5301.81

    1、象字典一样选择

    DataFrame可以通过列明进行字典形式取值获得数据。比如上例,可以通过s[‘inc_perc’]获得数据,也可以通过列名的操作进行运算,也可以再通过字典增加列。如下例:

    2、象二维数组一样操作

    (1)、按行查看数据

    可以用DataFrame的values属性按行查看,比如

    print(s.values[2]) # 查看第三行

    # array([5.00000000e+00, 8.12123000e+03, 7.73450476e+03]),用科学计数法

    (2)、行列转置后取特定行值

    比说我们要看广东的数据,但不能通过行名选择,可以通过转置

    print(s.T['GuangDong'])

    # 输出结果

    # inc_per 10.300000

    # receipts 10390.330000

    # last_year 9420.063463

    Name: GuangDong, dtype: float64

    (3)、用索引器取值

    pandas索引器loc,iloc,ix,会在DataFrame取值的利器

    print(s.iloc[:2, :3]) # 选择前两行,前三列,如同Excel的区域选择,iloc索引器

    # inc_per receipts last_year

    # BeiJing 7.5 5031.30 4680.279070

    # GuangDong 10.3 10390.33 9420.063463

    print(s.loc['ShanDong':'ShangHai',:'inc_per']) # 按显式索引取值,loc索引器

    # inc_per

    # ShanDong 8.5

    # ShangHai 16.1

    print(s.ix['BeiJing':'JiangSu',:2]) # 混合索引,ix索引器

    # inc_per receipts

    # BeiJing 7.5 5031.30

    # GuangDong 10.3 10390.33

    JiangSu 5.0 8121.23

    (4)、其他方式取值,比如掩码

    print(s.loc[s['inc_per']>10,['receipts']]) # 取增长率大于10%的各省财政收入

    # receipts

    # GuangDong 10390.33

    # ShangHai 6406.13

    everyang原创20180425,待续

    展开全文
  • 3.Pandas数据取值与选择

    千次阅读 2020-07-18 18:41:13
    文章目录Pandas数据取值与选择1.Series对象数据选取方法将Series对象看做字典取值添加值检索值和键将Sereies对象看做一维数组将显式索引作为切片将隐式数字作为切片掩码操作花哨的索引索引器:loc,iloc和ixloc索引器...
  • r.values[0]
  • 头歌 2. Pandas数据取值与选择

    千次阅读 2022-03-19 18:41:03
    头歌 2. Pandas数据取值与选择
  • 33_Pandas.DataFrame,Series和Python标准列表的相互转换 pandas.DataFrame,pandas.Series和Python标准list类型列表可以相互转换。 这里,将描述以下内容。 将list类型列表转换为pandas.DataFrame,pandas.Series ...
  • Pandas.Series索引iloc与loc的区别

    千次阅读 2020-01-13 02:02:28
    import pandas as pd A = [1,2,3,4] A = pd.Series(A,index=['a','b','c','d']) print("iloc输出结果: ",A.iloc[1]) # 普通索引,根据下标找 print("loc输出结果: ",A.loc['c']) # 在索引inde...
  • 1.series数据类型 1. Series相当于数组numpy.array类似 Series 它是有索引,如果我们未指定索引,则是以数字自动生成。 obj=Series([4,7,-5,3]) print obj #输出结果如下: 0 4 1 7 2 -5 3 3 如果数据被存在一个...
  • Pandas两重山之Series(循环)

    千次阅读 2021-12-03 08:59:02
    配合Python的高阶函数map、apply,匿名函数lambda,进行高校的Series数据操作哦!
  • pandas读取csv,并进行Series取值操作

    千次阅读 2021-01-08 11:35:24
    import pandas as pd df1 = pd.read_csv('test.csv') print(df1) ''' 打印: userId score age 0 1 45 18 1 2 65 19 2 3 58 17 3 4 92 16 4 5 78 18 ''' #获取一列,即Series数据获取 series1 = df1['s
  • Python Pandas Series数据添加、选取、切片方法 1. 添加 与字典添加新的键值对操作相同。 2. 选取 通过对象直接选取 通过显式索引选取 通过隐式索引选取 3. 切片 我们可以将Series对象看做NumPy数组,因此...
  • 2.数据取值与选择 2.1 Series数据选择方法 2.1.1 将Series看作字典 利用键值对索引 利用字典的表达式检测索引和值 2.1.2 将Series看作一维数组 可以利用索引-显式、隐式,掩码进行索引 2.1.3 索引器 loc iloc ...
  • Pandas基础——Series

    2021-05-24 16:25:38
    本文将讲解Pandas数据结构中的SeriesSeries类似于字典,但不是字典,因为他的索引可以是重复的。 一、Series的创建 使用pd.Series() 从DataFrame中取出一行或者一列 1.1、 使用pd.Series() 第二种方法主要在...
  • Pandas Shift函数基础 官方帮助文档如下: >>> import pandas >>> help(pandas.DataFrame.shift) Help on function shift in module pandas.core.frame: shift(self, periods=1, freq=None, ...
  • Pandas Series入门教程

    2022-04-15 12:37:22
    Pandas Series入门教程 Series 结构,也称 Series 序列,是 Pandas 常用的数据结构之一,它是一种类似于一维数组的结构,由一组数据值(value)和一组标签组成,其中标签与数据值之间是一一对应的关系。 Series 可以...
  • pandas中的series数据类型

    千次阅读 2020-12-15 14:39:23
    importpandas as pdimportnumpy as npimportnames'''写在前面的话:1、series与array类型的不同之处为series有索引,而另一个没有;series中的数据必须是一维的,而array类型不一定2、可以把series看成一个定长的有序...
  • pandas详解(Series篇)

    千次阅读 多人点赞 2019-08-06 20:50:10
    文章目录基础铺垫:pandas简介:pandas基本数据结构:Series:Series创建:Series索引:Series值的获取:Series运算:Series 缺失值检测:Series自动对齐:Series及其索引的name属性: 基础铺垫: pandas简介: &...
  • pandas Series

    2021-09-28 11:51:26
    Series 结构,也称 Series 序列,是 Pandas 常用的数据结构之一,它是一种类似于一维数组的结构,由一组数据值(value)和一组标签组成,其中标签与数据值之间是一一对应的关系。Series 可以保存任何数据类型,比如...
  • 文章目录Series一、导入Series二、创建Series1、使用列表或者numpy进行创建,默认索引为0到N-1的整数型索引2、使用字典创建(推荐使用)三、Series的索引和切片1、显式索引与切片2、隐式索引与切片四、Series的基本...
  • Pandas数据处理之数据取值与选择

    千次阅读 2019-06-18 12:56:40
      本篇介绍PandasSeries和DataFrame对象的数据获取与调整操作. 一、Series数据选择方法   Series对象与一维Numpy数组和标准字典在许多方面都一样。 1.将Series看做字典   和字典一样,Series 对象提供了键值...
  • 一、Series与python字典对比 Series兼并了数组和字典的功能,既可以看作是一种特殊的字典,又可以看成是通用的Numpy数组。既可以支持数组的切片操作等,还可以运用字典获取values...#字典的取值方法 print('dic:',dic
  • 通过层次化索引,pandas能够以较低维度形式处理高纬度的数据 通过层次化索引,可以按照层次统计数据 层次索引包括Series层次索引和DataFrame层次索引 1.2 Series的层次索引 import numpy as np import pandas as pd...
  • dataFrame中的值以矩阵的形式...1、dataFrame简单的取值方法import pandas as pddef createDataFrame():d = {'a':[1,2,3,4,5],'b':[6,2,3,6,0],'c':[4,2,3,6,7],'d':[5,3,2,4,5],'e':[6,7,4,5,8]}df = pd.DataFrame...
  • pandas-series索引

    千次阅读 2020-01-03 20:42:28
    目录1.Series概念2.创建方式3.索引3.1 标签索引与位置索引3.2 索引返回的是...索引index:一维数组值对应的标签,可以利用索引取值。 值values:一维数组的各元素值,是一个ndarray类型数据。 2.创建方式 先给出结...
  • 文章目录三、数值取值与选择1.Series数据选择方法1). 将Series看作字典2). 将Series看作一维数组3). 索引器: loc、 iloc和ix2.DataFrame数据选择方法 三、数值取值与选择 1.Series数据选择方法 Series 对象与一维 ...
  • 内容目录Series简介Series的创建方式Series索引和切片Series基本操作1 Series简介Pandas 是python的核心数据分析支持库,提供了快速、灵活、明确的数据结构,旨在简单、直观地处理关系型、标记型数据。pandas的两大...
  • Pandas创建对象与取值

    2022-05-07 21:41:34
    文章目录创建Series对象(一维)创建DataFrame对象(二维)创建DataFrame对象columns创建Index对象(不可变数组)交 并 异或 创建Series对象(一维) Series对象是带有索引数据构成的数组,可以作为...import pandas

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,429
精华内容 2,171
关键字:

pandas series取值