Jimmy那些事儿

Python_数据处理_pandas

发表 | 更新 | 分类 ， ， | 阅读次数

pandas 指引 : http://pandas.pydata.org/pandas-docs/stable/api.html#function-application-groupby-window

  • DataFrame 单独取出一列是 Series 格式

[TOC]


创建与变更格式

创建对象

  • pd.Series( [], index=[], name=’’ )：创建Series
  • pd.DataFrame(np.random.rand(20,5) , index=[], columns=[] )：创建20行5列的随机数组成的DataFrame对象

DataFrame会自动创建索引，且会被有序排列； Index索引对象是不可修改的。除非在第一次写入时缺少索引列，可进行定义。

传入等长的列表或NumPy数组组成的 字典。

若传入的列在数据中查询不到，就会产生NA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
DataFrame(obj, colums=[], index=[])
# columns  按照指定的列进行显示
# index  指定索引的名称，但并不改变行的顺序; 	若对已存在的索引（eg:嵌套字典），若index中的索引不存在，则不显示
# 创建对象：运用字典--------------------
data = {'state': ['Ohi', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'year': [2000,
        2001, 2002, 2001, 2002], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data, columns = ['year', 'state', 'pop'], index=[1,2,3,4,2])  # 按照指定列进行排序
# 创建对象：运用列表
pd.DataFrame([[4,7],[5,10]],columns=['a','b'],index=[1,2])
# ------嵌套字典-----------
pop = {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 
       2002: 3.6}}
frame3 = DataFrame(pop)



查看数据

  • df.shape()：查看行数和列数
  • df.head(n)：查看DataFrame对象的前n行
  • df.tail(n)：查看DataFrame对象的最后n行
  • df.describe()：查看数值型列的汇总统计
  • df.columns ：查看列名
  • s.value_counts(dropna=False)：查看Series对象的唯一值和计数
  • df.apply(pd.Series.value_counts)：查看DataFrame对象中每一列的唯一值和计数
  • http://df.info()：查看索引、数据类型和内存信息



数据整理

重命名 - rename

  • df.set_index(‘column_one’)：更改索引列
  • df.columns：获取当前列名
  • df.columns = [‘a’,’b’,’c’]：重命名列名
  • df.rename( columns = {‘a’ : ‘A’} , inplace = True )：只修改特定的列；将’a’ 改为 ‘A’
    • df.rename(columns=lambda x: x + 1)：批量更改列名
1
2
3
4
df.rename(columns={'old_name': 'new_ name'}) # 选择性更改列名
df.rename(columns=lambda x: x + 1) # 批量更改列名
df.rename(index=lambda x: x + 1) # 批量重命名索引


批量重命名 - 前缀/后缀

  • DataFrame.add_prefix(prefix) ：将前缀字符串与面板项名称串联在一起。
  • DataFrame.add_suffix(suffix)：将后缀字符串与面板项名称串联在一起。、
1
2
3
4
5
6
7
8
9
# 分组运算并合并数据
df.groupby('key1').transform('mean').add_prefix('mean_')  # DataFrame.add_prefix(prefix) 将前缀字符串与面板项名称串联在一起。
mean_data1	mean_data2
0	0.486419	-0.379653
1	0.486419	-0.379653
2	-0.771562	-0.562044
3	-0.771562	-0.562044
4	0.486419	-0.379653



排序 - sort_valuese

根据列的值进行排序

  • df.sort_values(col1)：按照列col1排序数据，默认升序排列
  • df.sort_values([col1,col2], ascending=[True,False])：先按列col1升序排列，后按col2降序排列数据
1
2
df.sort_value(col1, ascendding=False)
## ascendding=False，按照列col1降序排列数据；默认按升序排列

根据索引调整

  • df.sort_index(asix=1, ascending=False) ：根据索引/列名标签对数据结构进行调整

若axis=1，则根据列名的顺序进行调整结构，行不变。

  • df.reset_index()：重新设置行的索引
  • s.sort_index() ：根据索引进行排序
  • s.order()


列/行索引重排

  • DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)：根据新索引进行重新排序
    • 只显示符合当前索引的值。可加入新的索引值，若不存在则显示为NaN
    • axsi = 1 ，则表示对 [列 Columns ] 进行重排
    • 支持两种形式（建议采用第二种）
      • (index=index_labels, columns=column_labels, ...)
      • (labels, axis={'index', 'columns'}, ...)

labels : array-like, optional. New labels / index to conform the axis specified by ‘axis’ to.

index： 用作索引的新序列

axis : int or str, optional. Axis to target. Can be either the axis name (‘index’, ‘columns’) or number (0, 1).

fill_value ：缺失值NaN的替代值

method： = ffill /bfill；向前填充/向后填充；只适用于单调增长/减少的索引

limit： 向前或向后填充的最大填充量； 向前，即正向填充，向后一位数字（数值2位于1的前面）

level ：

copy： 默认为True，无论如何都复制；若为False，则新旧不相等时复制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> df
           http_status  response_time
Firefox            200           0.04
Chrome             200           0.02
Safari             404           0.07
IE10               404           0.08
Konqueror          301           1.00
>>> df.reindex(['http_status', 'user_agent'], axis="columns")
           http_status  user_agent
Firefox            200         NaN
Chrome             200         NaN
Safari             404         NaN
IE10               404         NaN
Konqueror          301         NaN
# 将制定的列提到最前面
df.reindex(['mean'] + list(df.columns[:-1]), axis=1)
  • df.index.is_unique()：判断索引值是否唯一，若某个索引对应多个值，则返回一个Series，否则返回单个值



排名 - rank

  • df.rank(method = ‘’)：会把对象的 values 替换成名次
    • 排名作用与排序的不同之处在于，它会把对象的 values 替换成名次。 这时唯一的问题在于如何处理平级项，方法里的 method 参数就是起这个作用的

method 排名时处理平级值的方式。

average ：默认，为各个值分配平均排名

min：使用整个分组的 [最小] 排名

max：使用整个分组的 [最大] 排名

first：按值在原始数据中的出现顺序分配排名

  • max 与 min的区别：相等时，显示的排名按最大/最小排名来显示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# ------------示例-------------
obj = Series([1,2,3,3,4,4,4]) 
obj.rank(method='max')  # 对于3这个值，最大排序为4，所以显示4
0    1.0
1    2.0
2    4.0
3    4.0
4    7.0
5    7.0
6    7.0
obj.rank(method='min')  # 对于3这个值，最下排序为3，所以显示3
0    1.0
1    2.0
2    3.0
3    3.0
4    5.0
5    5.0
6    5.0

格式转换

  • ​


布局转换 - 长宽格式

宽格式 $\to$ 长格式

  • df.melt(id_vars=[‘A’], value_vars=[‘B’, ‘C’])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
df.melt(id_ars=[], value_vars=[], var_name='', value_name='')
## id_vars，以该变量为基准进行重构
## vaule_vars，需要将哪些变量组合进id列的变量，其值自动填充
# 示例-------------------
>>> df
   A  B  C
0  a  1  2
1  b  3  4
2  c  5  6
df.melt(id_vars=['A'], value_vars=['B', 'C'])
   A variable  value
0  a        B      1
1  b        B      3
2  c        B      5
3  a        C      2
4  b        C      4
5  c        C      6


长格式 $\to$ 宽格式

  • df.pivot(val1, val2, val3)：将df的val1作为[行]索引的列名，val2为用作[列]索引的列名，val3作为用于[填列值]的列名



层次化索引的重塑 - stack

  • stack()：列转行；将数据的列 “旋转” 为行
  • unstack()：列转行；将数据的行 “旋转” 为列

stack操作的是对最内层的索引进行操作。

若用字符串表示，则直接输入该索引的名称 .stack(‘number’)

若用数字表示，0 - 第一层索引； 1 - 第二层索引


数据透视表

  • df.pivot_table(index=col1, values=[col2,col3], aggfunc=max)：创建一个按列col1进行分组，并计算col2和col3的最大值的数据透视表


格式：数字、时间与日期

pandas库是基于整列的操作

格式转换 - 通用

  • DataFrame.astype(dtype, copy=True, errors=’raise’, **kwargs) ：Cast a pandas object to a specified dtype dtype

dtype : data type, or dict of column name

1
2
3
4
5
6
7
8
9
>>> ser = pd.Series([1, 2], dtype='int32')
>>> ser
0    1
1    2
dtype: int32
>>> ser.astype('int64')
0    1
1    2
dtype: int64  # dtype 注意此处



数字操作

格式转换

  • pandas.to_numeric(arg, errors=’raise’, downcast=None) ：将变量转为数值类型

arg : list, tuple, 1-d array, or Series

downcast : {‘integer’, ‘signed’, ‘unsigned’, ‘float’} , default None

  • ‘integer’ or ‘signed’: smallest signed int dtype (min.: np.int8)
  • ‘unsigned’: smallest unsigned int dtype (min.: np.uint8)
  • ‘float’: smallest float dtype (min.: np.float32)



数字格式定义

  • str.format( { : } ) ：格式化输出字符串使用format()函数, 字符串即类, 可以使用方法。可使用 print("FORMAT".format(NUMBER)); 来运行示例 http://blog.xiayf.cn/2013/01/26/python-string-format/
    • 语法是{ }中带 : 号 '{:,}'.format('str')
    • 符号 {} 是替换变量的占位符
    • 转义大括号：若你需要使用大括号，只要写两次就可以了

字符串的参数使用 { num } 进行表示 ,0, 表示第一个参数,1, 表示第二个参数

使用“:”, 指定代表元素需要的操作 , 如”:.3”小数点三位, “:8”占8个字符空间等;

添加特定的字母

‘b’ - 二进制. 将数字以2为基数进行输出.

‘c’ - 字符. 在打印之前将整数转换成对应的Unicode字符串.

‘d’ - 十进制整数. 将数字以10为基数进行输出.

‘o’ - 八进制. 将数字以8为基数进行输出.

‘x’ - 十六进制. 将数字以16为基数进行输出, 9以上的位数用小写字母.

‘e’ - 幂符号. 用科学计数法打印数字, 用’e’表示幂.

‘g’ - 一般格式. 将数值以fixed-point格式输出. 当数值特别大的时候, 用幂形式打印.

‘n’ - 数字. 当值为整数时和’d’相同, 值为浮点数时和’g’相同. 不同的是它会根据区域设置插入数字分隔符.

‘%’ - 百分数. 将数值乘以100然后以fixed-point(‘f’)格式打印, 值后面会有一个百分号.

对齐方式

< （默认）左对齐

> 右对齐

^ 中间对齐

= （只用于数字）在小数点后进行补齐

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 主要用法 
'{:,}'.format('str')
# 符号 {} 是替换变量的占位符。若没有指定格式，则直接将变量值作为字符串插入。 
"glazed with {} water beside the {} chickens".format("rain", "white")
# 可以使用变量的位置数值，在字符串中改变它们，进行格式化时。如果搞错了顺序，你可以轻易地修正而不需要打乱所有的变量。
s1 = " {0} is better than {1} ".format("emacs", "vim")
s2 = " {1} is better than {0} ".format("emacs", "vim")
# 默认顺序为0
str = "Oh {0}, {0}! wherefore art thou {0}?".format("Romeo")
>>> Oh Romeo, Romeo! wherefore art thou Romeo?
# 命名参数：将新的格式字符串用作模板引擎，使用命名参数，这样就不要求有严格的顺序。
madlib = " I {verb} the {object} off the {place} ".format(verb="took", object="cheese", place="table")
>>> I took the cheese off the table
# 转义大括号：若你需要使用大括号，只要写两次就可以了
print(" The {} set is often represented as { {0} } ".format("empty"))


数字 格式 输出 描述
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {:+.2f} +3.14 带符号保留小数点后两位
-1 {:+.2f} -1.00 带符号保留小数点后两位
2.71828 {:.0f} 3 不带小数
5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)
10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)
1000000 {:, } 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00e+09 指数记法
13 {:10d} 13 右对齐 (默认, 宽度为10)
13 {:<10d} 13 左对齐 (宽度为10)
13 {:^10d} 13 中间对齐 (宽度为10)


【应用到列】

1
2
3
4
5
6
# 定义函数
de format_qian(a):
  b = '{:,}'.format(a)
  retrun(b)
  
qian_all_data['参与人次'].apply(format_qian)



日期操作

格式转换

#####转为日期格式

  • pandas.to_datetime( arg, errors=’raise’, dayfirst=False, yearfirst=False, utc=None, box=True, format=None, exact=True, unit=None, infer_datetime_format=False, origin=’unix’ )：将字符类型转化成时间格式

dayfirst : boolean, default False ; If True, parses dates with the day first, eg 10/11/12 is parsed as 2012-11-10.

box : boolean, default True

  • If True returns a DatetimeIndex
  • If False returns ndarray of values.

format : string, default None

errors : {‘ignore’, ‘raise’, ‘coerce’}, default ‘raise’

  • If ‘raise’, then invalid parsing will raise an exception 引发异常
  • If ‘coerce’, then invalid parsing will be set as NaT
  • If ‘ignore’, then invalid parsing will return the input

unit : string, default ‘ns’

unit of the arg (D,s,ms,us,ns) denote the unit

1
2
3
4
5
6
7
8
9
10
11
12
>>> df = pd.DataFrame({'year': [2015, 2016],
                       'month': [2, 3],
                       'day': [4, 5]})
>>> pd.to_datetime(df)
0   2015-02-04
1   2016-03-05
dtype: datetime64[ns]
  
  
# 指定格式  
>>> pd.to_datetime('13000101', format='%Y%m%d', errors='ignore')
datetime.datetime(1300, 1, 1, 0, 0)


#####转为日期差值

  • pandas.to_timedelta(arg, unit=’ns’, box=True, errors=’raise’) ：Convert argument to timedelta
    • timedelta 表示两个datetime之间的时间差。
1
2
3
>>> pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])
TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015', NaT],
               dtype='timedelta64[ns]', freq=None)
  • DatetimeIndex.strftime(date_format) ：返回指定格式的字符串格式


  • Series.dt.strftime(*args, **kwargs) ：单列转为字符串格式，格式化输出

date_format : str ; date format string (e.g. “%Y-%m-%d”)

  • Timestamp.strptime() ：string, format -> new datetime parsed from a string (like time.strptime()).

    ​


####基本操作

【选取】

1
2
# 过滤某个时间片的数据&取某个时间片的数据
df[df['date']<=pd.datetime(2016,6,10)]

【返回】

1
2
3
4
# 返回某个日期是周几
pd.to_datetime(df['date']).dt.weekday_name   # 返回星期名；
pd.to_datetime(df['date']).dt.weekday  # 返回数字；

【判断】

  • dt.is_month_start ：判断是否为一个月的第一天
  • dt.is_month_end：判断是否为一个月的最后一天



日期格式定义

【datetime格式定义】

代码 说明
%Y 4位数的年
%y 2位数的年
%m 2位数的月 [01, 12]
%d 2位数的日 [01, 31]
%F %Y-%m-%d 简写形式；2012-04-18
%D %m/%d/%y 简写形式；04/18/12
%H 时间（24小时制） [00, 23]
%I 时间（12小时制） [00, 12]
%M 2位数的分钟 [00, 59]
%S 秒 [00, 61] (秒60和61用于闰秒)
%w 用整数表示的星期几 （星期天为第0天） [0, 6]
%U 每年的第几周 [00, 53]。星期天被认为是每周的第一天，每年第一个星期天之前的那几天被认为是 “第0周”
%W 每年的第几周 [00, 53]。星期一被认为是每周的第一天，每年第一个星期一之前的那几天被认为是 “第0周”
%z 以+HHMM 或-HHMM 表示的UTC时区偏移量


【特定于当前环境的日期格式】

代码 说明
%a 星期几的简写
%A 星期几的全称
%b 月份的简写
%B 月份的全称
%c 完成的日期和时间；Tue 01 May 2012 04:20:57 pm
%p 不同环境中的AM 或PM
%x 适用于当前环境的日期格式 ；若在美国， “May 1 2012” 会产生 “05/01/2012”
%X 适用于当前环境的时间格式； “04:24:12 PM”




##合并数据

横向合并 - 类同 join

  • DataFrame.join(other, on=None, how=’left’, lsuffix=’’, rsuffix=’’, sort=False)

    other : DataFrame, Series with name field set, or list of DataFrame

    • 方法对象必须是DataFrame，但join的对象可以是多个类型的；通用性比 pd.merge 更加好

    on ：若不指定，按照索引来进行join； column name, tuple/list of column names, or array-like Column(s) in the caller to join on the index in other.

    lsuffix / rsuffix : string. Suffix to use from left /right frame’s overlapping columns； 均在已有列名之后跟字符串

    sort : boolean, default False

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 使用索引进行连接
>>> caller.join(other, lsuffix='_caller', rsuffix='_other')
>>>     A key_caller    B key_other
    0  A0         K0   B0        K0
    1  A1         K1   B1        K1
    2  A2         K2   B2        K2
    3  A3         K3  NaN       NaN
    4  A4         K4  NaN       NaN
    5  A5         K5  NaN       NaN
    
    
    
# 使用关键列进行连接；需要指定连接的列名
>>> caller.join(other.set_index('key'), on='key')


  • pd.merge(df1,df2, on =’val’, how=’inner’)：将df1，df2根据val列进行内联接
    • pd.merge(df1, df2, on = ,[left_on=] how = , [left_index=False, srot=True, copy=True, suffixes=(‘_x’,’_y’)])

df1, df2 ：必须都是DataFrame

on = ‘val’ 用于连接的列名；若不指定则以列名的交集作为连接列

  • 当涉及左右两个表单列名不相同时，需使用left_on / right_on
  • left_on = ‘val1’ 左侧表中用作连接的列
  • right_on = ‘val2’ 右侧表中用作连接的列

left_index / right_index =True ,将索引列作为 [连接列]

how = ‘inner’ / ‘left’ / ‘right’ / ‘outer’ （outer为求并集）

sort = True/False ，根据连接列对合并的数据进行排序，默认为True

suffixs，字符串元组，在两个表中有重复的列名时，可用将字符串追加到重叠列名的末尾，默认为(‘_x’,’_y’)

copy = True，默认为True，即将结果复制到数据结构中


对于层次化索引，以 [列表的形式] 指名作用合并键的多个列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
> pd.merge(lefth, righth, left_on = ['key1', 'key2'], right_index=True)
>    data   key1  key2  event1  event2
> 0     0   Ohio  2000       4       5
> 0     0   Ohio  2000       6       7
> 1     1   Ohio  2001       8       9
> 2     2   Ohio  2002      10      11
> 3     3  Nevda  2001       0       1
>
> lefth
>    data   key1  key2
> 0     0   Ohio  2000
> 1     1   Ohio  2001
> 2     2   Ohio  2002
> 3     3  Nevda  2001
> 4     4  Nevda  2002
>
> righth
>             event1  event2
> Nevda 2001       0       1
>       2000       2       3
> Ohio  2000       4       5
>       2000       6       7
>       2001       8       9
>       2002      10      11
>


纵向合并 - 增加行

  • df1.append(df2)：将df2中的 [行] 添加到df1的尾部
  • df.concat([df1,df2], ignore_index = True) ：纵向合并，将df2中的 [所有行] 添加到df1的尾部

ignore_index = True，表示进行纵向合并，不保留轴上的索引，产生一组新的索引



数据选取与删除

行列选取

涉及布尔判断时，默认的对象为所有观测行的所有列

选取的内容会包含索引与数值

通过索引方式返回的列只是相应数据的视图。对此所做的任何修改，会直接反映到源数据。

  • df[col]：根据列名，并以Series的形式返回 [列]
  • df[ [col1, col2] ]：以DataFrame形式返回 [多列]
  • df[ df[col] > 0.5 ]：选择col列的值大于0.5的所有行
    • 先对 df[col] >0.5 进行布尔判断，返回True 和 False，再选取所有True的值
    • 对具体的观测行进行条件选取 ；等价于 Select * From table where col > 0.5

也可为布尔型数组(过滤行)、切片（行切片）、布尔型DataFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 指定列中的特定值，并返回所有的行
data[data['three']>5]
          one  two  three  four
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15
# 返回布尔值
data > 5
            one    two  three   four
Ohio      False  False  False  False
Colorado  False  False   True   True
Utah       True   True   True   True
New York   True   True   True   True


  • df.loc[ n [, m] ] ：通过 [ 行标签 ] 索引行数据 。 主要基于标签的, 但也可以与布尔数组一起使用。
    • n 为行标签；若行标签为字符串，则也需要用字符串表示。loc[‘d’] 表示索引的是第’d’行（index 是字符）
    • 若出现m，则表示可以索引行与列
    • 起始索引值为0；
  • df.iloc[ n [,m] ]：通过 [ 行号 ] 索引行数据 。 主要基于整数位置 (从0到 length-1 轴), 但也可以与布尔数组一起使用。
    • n 为行号；
    • 若出现m，则表示可以索引行与列

loc 在index的标签上进行索引,范围包括start和end.

iloc 在index的位置上进行索引,不包括end. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# ---- loc -------
import pandas as pd
data = [[1,2,3],[4,5,6],[7,8,9]]  
index = [0,1,2]  
columns=['a','b','c']  
df = pd.DataFrame(data=data, index=index, columns=columns)  
>>> df 
a	b	c
0	1	2	3
1	4	5	6
2	7	8	9
>>>  df[0:1]
a	b	c
0	1	2	3
1	4	5	6
# 索引某行某列
df.loc['d',['b','c']]  
# ---- iloc -------
## 索引第一列的所有数据
df.iloc[:,[1]]


多条件选取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
data = [[1,2,3],[4,5,6],[7,8,9]]  
index = [0,1,2]  
columns=['a','b','c']  
df = pd.DataFrame(data=data, index=index, columns=columns)  
# 所有列的多条件选取
df[(df['b']>2 ) & (df['a']>1)]
    a	b	c
1	4	5	6
2	7	8	9
# 指定列的多条件选取
df['c'][(df['b']>2 ) & (df['a']>1)]
1    6
2    9
# 指定列的多条件选取
>>> df.loc[(df['b']>2 ) & (df['a']>1),'c']
1    6
2    9
Name: c, dtype: int64
# 指定多列的 多条件选择
df.loc[(df['b']>2 ) & (df['a']>1),'b':'c']
    
# 获取值
>>> df.loc[(df['b']>2 ) & (df['a']>1),'c'].values
array([6, 9], dtype=int64)


df.ix[1, val ] 因为容易混淆，建议不使用。

  • df.ix[1, val ]：既能通过行号，也可以通过索引位置来进行选取，但ix中的索引右端为包含； 因为容易混淆，建议不要使用。
    • 若行的索引名为数字时，在进行选中时，选择的为行索引的数值名称，而非位置
1
2
3
4
5
6
7
8
9
10
11
12
# 因行索引不为数字，故代表位置，右端不包含
data.ix[0:2]
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
# 因行索引为数字，故代表的为行索引的名称
data.ix[0:2]
	Id	Survived
0	1	0
1	2	1
2	3	1


###条件选取 - filter

  • df.filter(item=[val], like= , regex=’’, axis=1)：选择DataFrame中满足条件的子集
    • filter的条件判断是对 行索引/ 列名 进行的匹配，而非具体的观测值

item：指定的列名；若不指定，则表示全体

regex：满足正则表达式的列名 ，此时axis=1

like ：满足like的行索引的所有行，此时axis=0 （该功能是SQL中没有的）

axis = 1 ：基于列；

axis = 0 ：基于行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> df
one  two  three
mouse     1    2      3
rabbit    4    5      6
>>> # select columns by name
>>> df.filter(items=['one', 'three'])
         one  three
mouse     1      3
rabbit    4      6
>>> # select columns by regular expression
>>> df.filter(regex='e$', axis=1)
         one  three
mouse     1      3
rabbit    4      6
>>> # select rows containing 'bbi'
>>> df.filter(like='bbi', axis=0)
one  two  three
rabbit    4    5      6


###随机与排序选取

  • df.sample(frac=0.5)：随机选取所有数据中的50%的观测行
  • df.sample(n=10)：随机选取10行
  • df.nlargest(n, ‘value’)：根据’value’进行排列，并选取最前面的n个值
  • df.nsmallest(n, ‘value’):根据n进行排序，并选取最后面的n个值
  • s.iloc[0]：按位置选取数据
  • s.loc[‘index_one’]：按索引选取数据

重复值 - duplicated

  • df.duplicated()：判断是否有重复行
  • df.duplicates()：移除重复行，默认保留第一个出现的值组合
    • df.duplicates([val1, val2], take_last=True)：指定部分列进行重复项判断； take_last=True 指定保留最后一个
  • s.dropna()：将Series中删除所有包含空值的行
  • s.astype(float)：将Series中的数据类型更改为float类型
  • s.replace(1,’one’)：用‘one’代替所有等于1的值
  • s.replace([1,3],[‘one’,’three’])：用’one’代替1，用’three’代替3


唯一值 - unique

  • df[‘val’].unique：返回某一列的唯一值
  • df.[‘val’].value_conuts：计算列中每个值出现的次数


数据删除 - drop

  • df.drop(val, axis=0 )：删除索引行/变量列，并返回一个新的对象

axis默认为0，删除索引为val1,val2的观测 [行]

1
df.drop([val1,val2], axis=1)  # 删除列名为val1,val2的 [列]，并返回一个新的对象；
  • s.drop()


【实战演练】

返回某列中不为NUll的所有行

1
data1 = data0[data0['column'].notnull()]



创建新变量

往往需要用到apply函数，然后用 merge 或者 join 来进行合并


增加列

  • df[‘Volumn’] = df.Length * df.Height
1
2
3
4
5
6
7
In [219]: df['b']=1  
  
In [220]: df  
Out[220]:   
   c  a  b  
0  1  5  1  
1  2  6  1
  • pd.Series(my_list)：从可迭代对象my_list创建一个Series对象

若不指定索引 index = [‘’, ‘’ ] ，则会自动创建从0开始的索引列

通过索引返回/赋值的数据，是对应数据的视图；所做的修改都会直接反映在源数据上；

算术运算中，会自动对齐不同索引的数据，若对应索引不存在，则填充为NaN

1
2
3
4
5
obj2 = Series([4, 7, -5, 3], index = ['b', 'd', 'a', 'c'])  # 指定索引
# 字典创建：字典中的 键 = 索引
sdata = {'Ohio': 35000, 'Texas': 71000, 'Orgen': 16000, 'Utah': 5000}
obj3 = Series(sdata)
  • df.index = pd.date_range(‘1900/1/30’, periods=df.shape[0])：增加一个日期索引


apply

  • DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
    • 若提前定义了函数，默认将之前的才变量传入为第一个参数； 例如 apply(sum)，其实是将变量传递给sum()的第一个变量

func : Function to apply to each column/row

  • np.mean / np.sum ：常规统计函数均可用np.xxx 表示对每一列使用该函数
1
2
3
4
5
6
7
8
9
10
11
12
>>> df.apply(numpy.sum, axis=0) # equiv to df.sum(0)
# 定义链接的函数；为apply做准备；
def link(a):
    a = str(a)  # 必须是字符串格式
    link = 'http://xinyitong.gensee.com/webcast/site/entry/join-5c9543e2905146aa9a6f2b16bd1f6de0'
    c = '?nickName=visitor'
    return (link + c + a)
  
  
link_add = tb0['员工编号'].apply(link);



重编码 - 字符串

字符串操作：Python内置、Re模块、矢量化操作

Re模块的函数主要分三个大类：匹配模式、替换、拆分

矢量化”(简化)是重写循环的过程，使得不是将阵列的单个元素处理N次，而是将阵列的4个元素同时N / 4次处理。

  • 使用 str.func
  • 在str属性上使用索引
1
2
3
4
5
6
7
8
> # 使用str.func
> matches = df.str.match(pattern)
>
> # 在str属性上使用索引
> matches.str[0]
>
> matches.str.get(1)
>

>

  • 常常需要结合 apply 函数进行批量操作


Python 内置

  • find()：返回第一个发现的子串的第一个字符所在的位置；否则返回 -1
  • rfind()：返回最后一个发现的子串的第一个字符所在的位置；否则返回 -1
  • index()：返回子串第一个字符所在的位置；若没有找到返回ValueError
  • startswith() / endswith() ：判断字符是否以某个前缀/后缀 开始或结尾，返回True
  • count：返回子串在字符串中出现的次数（非重复）


Re模块

  • match(pattern, string, flags=0)：字符串string的开头 开始搜索正则表达式模式pattern；若匹配成功，则返回一个匹配对象（仅返回匹配的部分）；否则返回None
  • search(pattern,string, flags=0)：从字符串string中（任意位置）搜索正则表达式模式pattern 第一次出现的地方； 如果匹配成功，则返回一个匹配对象；否则返回None
  • findall(pattern, string [,flags]) ：在字符串string中搜索匹配pattern的所有内容，并返回一个匹配对象的 [列表 list]
  • finditer(pattern, string [, flags])：在字符串string中搜索匹配pattern的所有内容，返回一个迭代器，该迭代器返回一个匹配对象


矢量化的字符串方法

df.str.func

  • match() ：根据指定的正则表达式对各个元素执行re.match

  • findall()

  • startswith / endswith

  • contains() ：返回各字符串是否含有指定模式的布尔型数组

  • count：模式出现的次数

    ​


替换 - replace & sub

python内置

  • strip / lstrip / rstrip：去除空格（包括换行符）。相当于对各个元素执行x.strip()
  • ljust /rjust ：用空格（或其他字符）填充字符串的空白侧以返回符合最低宽度的字符串

  • df.replace(1,’one’)：用‘one’代替所有等于1的值

    • df.replcae([1,2], [‘one’, ‘two’]) ：多个值之间替换
    • df.replace({-999:na.nan, -1000:0})： 传入的参数也可以是字典

    replace - 替换； 此处的替换为对整个值进行查找，而非值中的部分值

    eg: 第3个观测行daf\n ，无法用 data.replace(’\n‘, ‘’) 进行替换

1
2
df.replace(old, new [,max])  # 将old值替换为new
# max，可选字符串, 替换不超过 max 次
  • lower / upper () ：转化为小写/大写


Re模块

  • re.sub(pattern, repl ,string, max = 0) : 把字符串string中所有匹配正则表达式pattern的地方 替换成 字符串 repl

    • 如果没有找到匹配 pattern 的串，则返回未被修改的 string。Repl 既可以是字符串也可以是一个函数。

    若max 的值没有给出，则对所有匹配的地方进行替换

  • subn() ：该函数的功能和 sub() 相同，但它还返回新的字符串以及替换的次数


矢量化的字符串

  • strip / lstrip / rstrip：去除空格（包括换行符）。相当于对各个元素执行x.strip()
  • pad()：在字符串左边、右边或两侧添加空白符
  • center()：相当于pad(side=’both’)
  • replace()：用指定字符串替换找到的模式
  • repeat()：重复值； s.str.repeat(3) 相当于对各个字符串执行 x *3
  • get()：获取各元素的第i个元素
  • len()：计算各字符串长度
  • lower / upper () ：转化为小写/大写



分隔与连接

Python内置

  • split：通过指定的分隔符将字符串拆分为一组子串

  • ‘sep’.join(seq) ：将字符串用作连接其他字符串序列的分隔符

    sep：分隔符；可以为空

    seq：要连接的元素序列、字符串、元组、字典

1
2
3
>>> seq1 = ['hello','good','boy','doiido']  
>>> print ':'.join(seq1)  
hello:good:boy:doiido


Re模块

  • split：根据找到的模式将字符串拆分为数段


矢量化字符串函数

  • split()
  • slice()：对Series中的各个字符串进行子串截取；
  • cat()：实现元素级的字符串连接操作，可指定分隔符


对象类型

  1. dir()：获得对象的所有属性与类型
  2. type() - 判断对象类型
  3. instance() - 判断一个对象是否为某种类型：返回布尔值Ture/Falses
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 指定判断类型
>>> isinstance('a', str)
True
>>> isinstance(123, int)
True
# 先创建判断的对象
>>> a = Animal()
>>> d = Dog()
>>> h = Husky()
>>> isinstance(h, Husky)
True
# 还可以判断一个变量是否是某些类型中的一种
>>> isinstance([1, 2, 3], (list, tuple))
True
>>> isinstance((1, 2, 3), (list, tuple))
True

能用type()判断的基本类型也可以用isinstance()判断


常规格式转化

  • int(x [,base ]) ：将x转换为一个整数
  • long(x [,base ]) ：将x转换为一个长整数
  • float(x)：将x转换到一个浮点数
  • str(x)：将对象 x 转换为字符串
  • repr(x)：将对象 x 转换为表达式字符串
  • eval(str) ：用来计算在字符串中的有效Python表达式,并返回一个对象
  • tuple(s)：将序列 s 转换为一个元组
  • list(s)：将序列 s 转换为一个列表
  • chr(x) ：将一个整数转换为一个字符
  • unichr(x) ：将一个整数转换为Unicode字符
  • ord(x)：将一个字符转换为它的整数值
  • hex(x)：将一个整数转换为一个十六进制字符串
  • oct(x)：将一个整数转换为一个八进制字符串
  • complex(real [,imag ])：创建一个复数



缺失值

###判断

  • df.isnull()：检查DataFrame对象中的空值，并返回一个Boolean数组
  • df.notnull()：检查DataFrame对象中的非空值，并返回一个Boolean数组

Python中内置的None会被当做NA处理

pandas用浮点值NaN (Not a Number) 表示浮点和非浮点数据中的缺失数据；其类型为 float


###移除

  • df.dropna()：删除所有包含空值的行，返回为剔除后的对象（一行中只要有一个值为NaN，就删除整行）
1
2
3
4
5
df.dropna(how='all', axis=1, thresh=n)
## how='all', 指定排除一行中 [所有值均NA] 行/列
## axis=1, 删除所有包含空值的 [列]; 默认axis=0, 即删除所有包含空置的[行]
## axis=1,thresh=n, 删除所有 [小于n个非空值] 的 [行]


###重编码

  • df.fillna(x, inplace=True)：用x替换DataFrame对象中所有的空值，inplace表示在源数据中修改
1
2
3
4
5
6
7
8
9
fillna(value [, method = 'ffill',limit =n, axis=0, inplace=False])
# value 填充值
# method 差值方式，默认为ffill；也可为bfill
# limit  可以连续填充的最大数量
# axis 待填充的轴，默认为0
# inplace 默认为False，表示返回新对象；若为True，则对原始数据进行修改
df.fillna(0)  # 将缺失值替换为0
df.fillna({1: 0.5, 3: -1})  # 对位置值为1的 [列]，缺失值替换为0.5；即对第二列，将NaN值替换为0.5



汇总与描述统计

常规情况下，axis=1 代表列； axis=0 代表行；

计算情况下，axis=1 代表沿着每一行遍历所有的列，并向下执行方法


常规统计值

  • count()：非NA的数量
  • describe()：计算统计汇总
  • sum()
  • mean() / median()
  • quantile()
  • min() / max()
  • var()：方差 / std()：标准差
  • mad() :根据平均值计算平均绝对离差
  • argmin() / argmax()：计算能够获取到最小值/最大值的索引位置（整数） （对应 iloc）
  • idxmin() / idxmax()：计算能过获取到最小值/最大值的所索引值 （对应loc）


常规统计值 - 高阶

  • cumsum()：累计和
  • cummin() /cummax() ：累计最小值/累计最大值
  • cumprod()：累计积
  • skew()：偏度（三阶矩）
  • kurt()：峰度（四阶矩）
  • diff()：一阶差分（对时间序列很有用）
  • pct_change()：百分数变化
  • corr()：相关系数
  • ocv()：协方差


数据聚合与分组

分组聚合是由三个过程来组成的：拆分Split - 应用Apply - 合并Combine

  1. 数据根据所提供的一个或多个键被拆分 (Split) 为多组。并且拆分操作是在对象的特定轴 (axis=1 列； 或 axis=0 - 行)上执行的
  2. 将一个函数Apply应用到各个分组并产生一个新的值
  3. 将所有的结果合并Combine到最终结果的对象中

grouped 是一个GroupBy对象。它实际上还没有进行任何计算，只是包含了一些有关分子间df[‘key1’]的中间数据而已。该对象已经有了所需的一切信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas as pd
import numpy as np
df = pd.DataFrame({'key1':['a','a','b','b','a'],
               'key2':['one','two','one','two','one'],
               'data1':np.random.randn(5),
               'data2':np.random.randn(5)})
# grouped 是一个GroupBy对象。它实际上还没有进行任何计算，只是包含了一些有关分子间df['key1']的中间数据而已
grouped = df['data1'].groupby(df['key1'])
grouped
<pandas.core.groupby.SeriesGroupBy object at 0x000000000876EBA8>
# 调用GroupBy的方法进行聚合计算
grouped.mean()
       key1
a    0.486419
b   -0.771562
Name: data1, dtype: float64


分组

groupby：在分组的基础上，计算非NA的值统计量；

并且对所有的数值数据进行统计计算，而对非数据数据列则会排除。

默认对axis=0上进行分组；该场景应认为是计算的场景，axis=0 表示以列为单位，遍历每一行；即对该列中的各个值进行分组；效果等同于SQL中的groupby

  • df.groupby(‘ col’ )：返回一个按列col进行分组的Groupby对象
  • df.groupby( [‘col1’,’col2’] )：多条件分组； （ 等价于SQL中Group by key1, key2 ）
  • df.groupby().size()：返回一个包含分组大小的Series

as_index = False ：以 “无索引” 的形式返回聚合数据

group_keys = False ：禁止分组键。分组键会跟原始对象的索引共同构成结果对象中的层次化索引。该函数可禁止该效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# grouped 是一个GroupBy对象。它实际上还没有进行任何计算，只是包含了一些有关分子间df['key1']的中间数据而已
grouped = df['data1'].groupby(df['key1'])
grouped
<pandas.core.groupby.SeriesGroupBy object at 0x000000000876EBA8>
# 调用GroupBy的方法进行聚合计算
grouped.mean()
       key1
a    0.486419
b   -0.771562
Name: data1, dtype: float64
    
    
# 对所有的数值数据进行统计计算，而对非数据数据列则会排除。 'key2'列自动被排除在外
df.groupby('key1').mean()
      data1	data2
key1		
a	0.486419	-0.379653
b	-0.771562	-0.562044    
    
  
# -----------df.groupby(['col1', 'col2'])-----------------
# 一次传入多个数组，表示多条件分组 
df.loc[:,'data1'].groupby([df['key1'],df['key2']]).mean()  # 等价于SQL中 Group by key1, key2
           key1  key2
a     one     0.882282
      two    -0.305308
b     one    -1.010323
      two    -0.532800
Name: data1, dtype: float64
    
    
# ---------------Size--------------------
df.groupby('key1').size()
    key1
a    3
b    2
dtype: int64


层次化索引的重塑 - stack

可构建类似数据透视表的结构

  • stack()：列转行；将数据的列 “旋转” 为行
  • unstack()：列转行；将数据的行 “旋转” 为列

stack操作的是对最内层的索引进行操作。

若用字符串表示，则直接输入该索引的名称 .stack(‘number’)

若用数字表示，0 - 第一层索引； 1 - 第二层索引

1
2
3
4
5
6
df.loc[:,'data1'].groupby([df['key1'],df['key2']]).mean().unstack()
key2	one	two
key1		
a	0.882282	-0.305308
b	-1.010323	-0.532800


选取部分列 分组

  • df[‘data1’].groupby(df[‘key1’])：返回的一个已分组的数据框对象（语法糖：df.groupby(‘key1’)[‘data1’] ）
  • df[[‘data1’]].groupby(df[‘key1’]) ： 语法糖为df.groupby(‘key1’)[[‘data1’]]


通过函数 - 分组

  • 任何被当做分组键的函数都会在各个索引值 （行的索引值，而非列名）上被调用一次，其返回值就会被用作分组名称。

    • 若索引为人的名字；假设你希望根据人名的长度进行分组，虽然可以求取一个字符串长度数组，但其实仅需 传入len函数即可
    1
    people.groupby(len).sum()


####通过索引级别 - 分组

针对层次化索引数据集，可以根据索引级别进行分组；通过level 关键字传入 级别编码 或者 名称 即可。

  • df.groupby(level=’cty’, axis=1).mean() 对层次化索引的数据，根据索引级别进行聚合.通过level关键字传入级别编号或名称
1
hier_df.groupby(level='cty', axis=1).count()



对分组进行迭代

通过字典或Series 分组

传入一个 字典或Series 根据其值的内容分别分组


数据聚合

聚合：从数组产生标量值的数据转换过程

GroupBy会高效地对Series进行切片，然后对各片调用Piece，最后将这些结果组装为最终结果


自定义聚合函数

将自定义的函数传入aggregate 或 agg方法即可

aggregation会返回数据的缩减版本，而transformation能返回完整数据的某一变换版本供我们重组。

  • df.groupby(col1).agg(np.mean)：返回按列col1分组的所有列的均值df 
1
2
3
4
def peak_to_peak(arr):
    return arr.max() - arr.min()
df.groupby('key1').agg(peak_to_peak)

优化过的GroupBy 方法

.count() ： 非NA值的数量
.sum() ： 非NA值的和
.mean()
.mdian()： 非NA值的算术中位数
.std / .var： 无偏（分母为n-1）标准差和方差
.min / .max
.prod()： 非NA值的积
.first / .last ：第一个和最后一个非NA的值


面向列的多函数应用

一次应用多个函数

  • df.groupby( [‘sum’, ‘mean’]) ：一次应用多个函数：对于描述统计，可以将函数名以 字符串str 的形式传入，并作为一个 列表list 传入，得到一个以相应的函数命名的列
  • df.groupby( [ (‘foo’, ‘mean’), (‘bar’, ‘sum’) ]) ：传入多个函数，并重命名列名。
    • 当传入的是一个由 (name, function)元组组成的列表list ，则各元组的第一个元素会被用作DataFrame的列名（可以将这种二元元组看做一个有序映射） 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
df.groupby('key1').agg(['sum','mean'])
	       data1	data2
       sum	mean	sum	mean
key1				
a	1.459256	0.486419	-1.138960	-0.379653
b	-1.543123	-0.771562	-1.124087	-0.562044
# ---- 先定义要传入的多个函数为对象A；也可以运行
fc = ['count', 'mean', 'max']    
df.groupby('key1').agg(fc)
			data1		data2
	count	mean	max	count	mean	max
key1						
a	3	0.486419	1.041325	3	-0.379653	0.010709
b	2	-0.771562	-0.532800	2	-0.562044	0.038084
# 传入带有自定义名称的元组列表
fc_name = [('计数','count'),('最大值','max')]

对不同的列使用不同的聚合函数

  • df.groupby(‘key1’).agg( { ‘tip’: np.max, ‘size’: ‘sum’} ) ：向 agg 传入一个列名映射到函数的 字典dict
    • df.groupby(‘key1’).agg( { ‘tip_pct’ : [‘min’, ‘,max’], ‘size’: ‘sum’}) ：对不同列完成不同数量的聚合


分组运算transform & apply

transform & apply 只能产生两种结果：

  1. 一个可以广播出去的标量值
  2. 一个相同大小的结果数组

aggregation会返回数据的缩减版本，而transformation能返回完整数据的某一变换版本供我们重组。

  • df.groupby(‘val’).transform( func )：将一个函数应用到各个分组，返回该结果的值； 若产生的是一个标量值，则该值会被广播出去。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
df.groupby('key1').transform('mean')
	data1	data2
0	0.486419	-0.379653
1	0.486419	-0.379653
2	-0.771562	-0.562044
3	-0.771562	-0.562044
4	0.486419	-0.379653
# 对比 df.groupby('key1').mean()
	   data1	data2
key1		
a	0.486419	-0.379653
b	-0.771562	-0.562044
# 分组运算并合并数据
df.groupby('key1').transform('mean').add_prefix('mean_')  # DataFrame.add_prefix(prefix) 将前缀字符串与面板项名称串联在一起。



apply 是更一般性的 “拆分-应用-合并”；

传入的函数一般都是需要提前定义的；而无法直接调用已有的函数（sum/mean等）

  • GroupBy.apply(func)：
    • data.apply(np.mean)：对DataFrame中的每一 [列] 应用函数np.mean

axis = 0 默认：以行为单位，遍历列的所以行；可以理解为 SQL中指定某列的Group by

axis = 1 ：以列为单位，遍历行的所有列。

1
2
3
4
5
6
7
8
9
10
11
# 定义函数：根据分组选出最高的5个tip_pct值
def top(df, n=5, column = 'tip_pct'):
    return df.sort_index(by=column)[-n:]
  
# 将该函数应用
tips.groupby('smoker').apply(top)
# -----------------------------------------------
# 如果传入的函数能够接受其他参数或关键字，可以将这些内容直接放在函数名后面一并传入apply
tips.groupby(['smoker', 'day']).apply(top, n=1, column = 'totoal_bill')


样式输出 - style

【提醒】

  • 采用格式化函数之后，整个对象类型则变更为 styler ，此时不应该赋值给原对象。因为赋值后，无法应用任何 DataFrame的函数；
  • 格式输出并不改变原对象的值
  • 在最后阶段应用格式化输出的函数

输出设置

  • Styler.format(formatter, subset=None)：格式化单元格的文本显示值
    • pandas.io.formats.style.Styler.format
    • 对象必须是 DataFrame；对于Series无效；即若只取 DataFrame的一列，则会报错；

formatter: str, callable, or dict

< formatter是 a 或 dict {column name： a} >； a 是如下之一

  • str: this will be wrapped in: a.format(x) ； 这将包装在：a.format(x)
  • callable: called with the value of an individual cell 使用单个单元格的值调用

subset: IndexSlice

An argument to DataFrame.loc that restricts which elements formatter is applied to

1
2
3
4
5
6
7
8
9
>>> df = pd.DataFrame(np.random.randn(4, 2), columns=['a', 'b'])
# 对所有对象调用格式化函数
>>> df.style.format('{:.2%}')  # 注意{}是用引号 括起来的
>>> df['c'] = ['a', 'b', 'c', 'd']
# 通过字典的方式来指定特定列的输出格式   
## 对于数值类型，直接调用format函数； 对于文本，直接调用str.func
df.style.format({'a':format('{:.2%}'),'b':format('{:.2%}'),'c':str.upper})

对于数值类型，直接调用format函数； 对于文本，直接调用str.func

格式化单元格的文本显示值。


参考说明

axis的含义

【结论】

  1. 常规情况下，axis=1 代表列； axis=0 代表行；
  2. 计算情况下，axis=1 代表沿着每一行遍历所有的列，并向下执行对一个的方法

如果我们调用df.mean(axis=1),我们将得到按行计算的均值

如果我们调用 df.drop((name, axis=1),我们实际上删掉了一列，而不是一行

df.mean其实是在每一行上取所有列的均值，而不是保留每一列的均值。也许简单的来记就是axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词（译者注）

换句话说：

  • 使用0值 表示沿着每一列或行标签\索引值向下执行方法
  • 使用1值 表示沿着每一行或者列标签模向执行对应的方法

下图代表在DataFrame当中axis为0和1时分别代表的含义:

img

axis参数作用方向图示

另外，记住，Pandas保持了Numpy对关键字axis的用法，用法在Numpy库的词汇表当中有过解释：

轴用来为超过一维的数组定义的属性，二维数据拥有两个轴：第0轴沿着行的垂直往下，第1轴沿着列的方向水平延伸。

所以问题当中第一个列子 df.mean(axis=1)代表沿着列水平方向计算均值，而第二个列子df.drop(name, axis=1) 代表将name对应的列标签（们）沿着水平的方向依次删掉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>>df = pd.DataFrame([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], \
columns=["col1", "col2", "col3", "col4"])
>>>df
   col1  col2  col3  col4
    0     1     1     1     1
    1     2     2     2     2
    2     3     3     3     3
    
>>> df.mean(axis=1)
0    1
1    2
2    3
>>> df.drop("col4", axis=1)
   col1  col2  col3
0     1     1     1
1     2     2     2
2     3     3     3


常见问题

两行相减 & 环比

1
2