loc() iloc() at() iat()函数

1 四个函数都是用于dataframe的定位

[]用于直接定位.

loc()函数是用真实索引,iloc()函数是用索引序号.

loc()函数切片是左闭右闭,iloc()函数切片是左闭右开.

at(),iat()的关系同上.

import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(24).reshape(6,4), columns=list('ABCD'), index=list('abcdef'))
print(df)

# 直接切片定位法   总结:取行时只能用切片,取列时只能用list选择列名
# 切片行时
# 注意切片用真实索引时是左闭右闭,
print(df['a':'d'])
# 用索引序号时是左闭右开
print(df[0:3])
# 当真实索引和索引序号相同时,切片是左闭右开
print(df.reset_index())
print(df.reset_index()[0:3])
# 切片列时
# 列索引必须是用真实索引,不能用索引序号,否则报错
print(df['a':'d'][['C','D']])
print(df['a':'d'])
# 且此方法不能对列名做切片,会报错
# print(df[['B':'D']])
# print(df[0:3][[2:3]])

#　loc()函数定位法
# loc()函数的固定结构如下,先写行索引,再写列索引
# 注意loc()的切片是左闭右闭,iloc()的切片是左闭右开
print(df.loc['b':'e',['A','D']])
print(df.loc[ df['A']> 8])
# 会报错,loc()只接受真实索引,iloc()只接受索引的序号,即必须是整数
# print(df.loc[ 2:4, ['A','D']])

# iloc()函数定位法
# iloc()只接受索引的序号,切片是左闭右开,同直接[]切片定位方法用索引序号时是一样的
print(df.iloc[0:4, 1:3])

# at()函数
# 只能定位单个元素，无法定位多个,用法同loc()
print(df.at['a','C'])
# iat()函数
# 只能定位单个元素，无法定位多个,用法同iloc()
print(df.iat[0,2])

# ix()
# 当索引列是时间时，允许用未在索引列中出现的时间做切片
# 在pandas版本0.20.0及其以后版本中，ix已经不被推荐使用，建议采用iloc和loc实现ix。
import random
import datetime as dt
rnd_1 = [random.randrange(1,20) for x in range(1000)]
rnd_2 = [random.randrange(1,20) for x in range(1000)]
rnd_3 = [random.randrange(1,20) for x in range(1000)]
fecha = pd.date_range('2012-4-10', '2015-1-4')
data = pd.DataFrame({'fecha':fecha, 'rnd_1': rnd_1, 'rnd_2': rnd_2, 'rnd_3': rnd_3})
print(data.describe())
date_1 = dt.datetime(2013, 1, 10, 8, 30)
date_2 = dt.datetime(2013, 1, 13, 4, 20)
data_fecha = data.set_index('fecha')
print(data_fecha.ix[date_1: date_2])
# print(data_fecha.loc[date_1,date_2])
# 参考：https://blog.csdn.net/wr339988/article/details/65446138

#     A   B   C   D
# a   0   1   2   3
# b   4   5   6   7
# c   8   9  10  11
# d  12  13  14  15
# e  16  17  18  19
# f  20  21  22  23
#     A   B   C   D
# a   0   1   2   3
# b   4   5   6   7
# c   8   9  10  11
# d  12  13  14  15
#    A  B   C   D
# a  0  1   2   3
# b  4  5   6   7
# c  8  9  10  11
#   index   A   B   C   D
# 0     a   0   1   2   3
# 1     b   4   5   6   7
# 2     c   8   9  10  11
# 3     d  12  13  14  15
# 4     e  16  17  18  19
# 5     f  20  21  22  23
#   index  A  B   C   D
# 0     a  0  1   2   3
# 1     b  4  5   6   7
# 2     c  8  9  10  11
#     C   D
# a   2   3
# b   6   7
# c  10  11
# d  14  15
#     A   B   C   D
# a   0   1   2   3
# b   4   5   6   7
# c   8   9  10  11
# d  12  13  14  15
#     A   D
# b   4   7
# c   8  11
# d  12  15
# e  16  19
#     A   B   C   D
# d  12  13  14  15
# e  16  17  18  19
# f  20  21  22  23
#     B   C
# a   1   2
# b   5   6
# c   9  10
# d  13  14
#
#
#              rnd_1        rnd_2        rnd_3
# count  1000.000000  1000.000000  1000.000000
# mean      9.912000    10.140000    10.134000
# std       5.370204     5.461156     5.458006
# min       1.000000     1.000000     1.000000
# 25%       5.000000     5.000000     5.000000
# 50%      10.000000    10.000000    10.000000
# 75%      14.000000    15.000000    15.000000
# max      19.000000    19.000000    19.000000
#             rnd_1  rnd_2  rnd_3
# fecha
# 2013-01-11      6     14      9
# 2013-01-12     10     19     11
# 2013-01-13     14      4     14

2 loc()函数用于定位dataframe的某些行,可以进行切片操作,当只定位一行时,数据类型是series.

有时想要按dataframe中的某一列按条件进行索引时,可以将该列设置为索引列,即可用loc函数进行索引定位.

import pandas as pd
df = pd.DataFrame([
            ['green', 'M', 10.1, 'class1'],
            ['red', 'L', 13.5, 'class2'],
            ['blue', 'XL', 15.3, 'class1']],
                 columns=['a','b','c','d'])
print(df)
print(df.loc[2][1])
print(type(df.loc[2]))
print(df.loc[:,'a'])  # 也可以选择多列输出
#        a   b     c       d
# 0  green   M  10.1  class1
# 1    red   L  13.5  class2
# 2   blue  XL  15.3  class1
# XL
# <class 'pandas.core.series.Series'>
# 0    green
# 1      red
# 2     blue
# Name: a, dtype: object

3 利用loc()函数定位dataframe的某些行后，可直接赋值修改某些列的值.特别要注意另一种写法不能修改值.

df = pd.DataFrame({ 'a': [3,4,3,7],
                    'b': [6,2,3,4],
                    'c': [3,5,4,3]})
# 注意想要修改满足条件的c列的值时,要把c列写入[]内
df.loc[(df['a'] == 3) & (df['b'] == 3),'c'] = '把我的值修改了'
df.loc[(df['a'] == 3) & (df['b'] == 3),'b'] = '把我的值也修改了'
print(df)
# 如下这种写法不会修改值,
print('第三行a列的值是：',df.loc[2].a)
df.loc[2].a = 999
print(df)
#    a         b        c
# 0  3         6        3
# 1  4         2        5
# 2  3  把我的值也修改了  把我的值修改了
# 3  7         4        3
# 第三行a列的值是： 3
#    a         b        c
# 0  3         6        3
# 1  4         2        5
# 2  3  把我的值也修改了  把我的值修改了
# 3  7         4        3

用series给series赋值时，一定要注意后面加上.values，否则容易出错.

import pandas as pd
df1 = pd.DataFrame({'a':[1,1,2,2],
                    'b':[2,4,6,8]})
df2 = pd.DataFrame({'c':[3,3,4,4],
                    'd':[6,7,8,9]})
print(df1)
print(df2)
# loc[]后定位的b列是series类型
print(type(df1.loc[ df1.a == 1, 'b']))
# 可以直接用list或ndarray进行赋值，不会出错
df1.loc[ df1.a == 1, 'b'] = [888,999]
print(df1)
# 注意这里赋值的时候右边生成的是series类型，如果与左边的series索引对不上，
# 就会出现空值，所以为了保险起见，加上.values就一定不会出错
df1.loc[ df1.a == 1, 'b'] = (df1.loc[df1.a == 2, 'b'] + df2.loc[df2.c == 4, 'd']).values
print(df1)
#    a  b
# 0  1  2
# 1  1  4
# 2  2  6
# 3  2  8
#    c  d
# 0  3  6
# 1  3  7
# 2  4  8
# 3  4  9
# <class 'pandas.core.series.Series'>
#    a    b
# 0  1  888
# 1  1  999
# 2  2    6
# 3  2    8
#    a   b
# 0  1  14
# 1  1  17
# 2  2   6
# 3  2   8

4 注意用loc选值的时候要用values[0]

import pandas as pd
df1 = pd.DataFrame({'a':[1,1,2,3],
                    'b':[2,4,6,8]})
print(df1)
# 注意这里想要取出对应的值要用values[0].
a = df1.loc[df1['a'] == 2, 'b'].values[0]
print(type(a))
print(a)
#    a  b
# 0  1  2
# 1  1  4
# 2  2  6
# 3  3  8
# <class 'numpy.int64'>
#