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
# 2
# 2
# 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'>
# 6