数据分析--pandas常用操作

最新推荐文章于 2024-09-13 08:50:19 发布

the uzi

最新推荐文章于 2024-09-13 08:50:19 发布

阅读量4.6k

点赞数 1

文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/Albert__Einstein/article/details/121665036

版权

python 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Pandas 是核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。Pandas 的目标是成为 Python 数据分析实践与实战的必备高级工具，本文主要总结数据分析中pandas的常用方法

python 版本：python3.7 pandas版本：'2.7.0'

1.引入模块

import pandas as pd
import numpy as np

2.数据生成

2.1Series

Series是带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。轴标签统称为索引。

调用 pd.Series 函数即可创建 Series：

s = pd.Series(data, index=index)

上述代码中，data 支持以下数据类型：

Python 字典

Series 按字典的插入顺序排序索引(python3.7)

data = {'a': 3, 'b': 1, 'c': 2}
s = pd.Series(data)
s

多维数组

data 是多维数组时，index 长度必须与 data 长度一致。没有指定 index 参数时，创建数值型索引，即 [0, ..., len(data) - 1]。

 s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

标量值（如，5）

data 是标量值时，必须提供索引。Series 按索引长度重复该标量值。

pd.Series(100., index=['a', 'b', 'c', 'd', 'e'])

2.2DataFrame

DataFrame 是由多种类型的列构成的二维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。DataFrame 是最常用的 Pandas 对象，与 Series 一样，DataFrame 支持多种类型的输入数据：

一维 ndarray、列表、字典、Series 字典

用多维数组字典、列表字典生成 DataFrame

多维数组的长度必须相同。如果传递了索引参数，index 的长度必须与数组一致。如果没有传递索引参数，生成的结果是 range(n)，n 为数组长度。

data = {'A': [1., 2., 3., 4.],
   'B': [4., 3., 2., 1.]}
pd.DataFrame(data)

pd.DataFrame(data, index=['a', 'b', 'c', 'd'])

用列表字典生成 DataFrame (自动生成range索引)

data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]

用 Series 字典或字典生成 DataFrame

生成的索引是每个 Series 索引的并集。先把嵌套字典转换为 Series。如果没有指定列，DataFrame 的列就是字典键的有序列表。

data = {'A': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'B': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df

pd.DataFrame(data, index=['d', 'b', 'a'])

 pd.DataFrame(data, index=['d', 'b', 'a'], columns=['A', 'B'])

用元组字典生成 DataFrame

元组字典可以自动创建多层索引 DataFrame。

pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},
            ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},
            ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},
            ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},
            ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}})

二维 numpy.ndarray

 pd.DataFrame(np.random.randn(5,5))

3.数据读取

3.1pandas读取excel

pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None, 
              usecols=None, squeeze=False,dtype=None, engine=None, 
              converters=None, true_values=None, false_values=None, 
              skiprows=None, nrows=None, na_values=None, parse_dates=False, 
              date_parser=None, thousands=None, comment=None, skipfooter=0, 
              convert_float=True, **kwds)

1、io，文件存储路径

io = /home/work/xxxx.xlsx

2、sheet_name，sheet名称

可以是整型数字、列表名或SheetN，也可以是上述三种组成的列表。

整型数字：目标sheet所在的位置，以0为起始，比如sheet_name = 1代表第2个工作表。

3、header，用哪一行作列名

4、names，自定义最终的列名

5、index_col，用作索引的列

6、usecols，需要读取哪些列

7、squeeze，当数据仅包含一列

8、converters ，强制规定列数据类型

9、skiprows，跳过特定行

10、nrows ，需要读取的行数

11、skipfooter ，跳过末尾n行

3.2pandas读取csv


pd.read_csv(filepath_or_buffer: Union[str, pathlib.Path, IO[~AnyStr]],
            sep=',', delimiter=None, header='infer', names=None, index_col=None,
            usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True,
            dtype=None, engine=None, converters=None, true_values=None,
            false_values=None, skipinitialspace=False, skiprows=None,
            skipfooter=0, nrows=None, na_values=None, keep_default_na=True,
            na_filter=True, verbose=False, skip_blank_lines=True,
            parse_dates=False, infer_datetime_format=False,
            keep_date_col=False, date_parser=None, dayfirst=False,
            cache_dates=True, iterator=False, chunksize=None,
            compression='infer', thousands=None, decimal: str = '.',
            lineterminator=None, quotechar='"', quoting=0,
            doublequote=True, escapechar=None, comment=None,
            encoding=None, dialect=None, error_bad_lines=True,
            warn_bad_lines=True, delim_whitespace=False,
            low_memory=True, memory_map=False, float_precision=None)

filepath_or_buffer为第一个参数，没有默认值，也不能为空，根据Python的语法，第一个参数传参时可以不写参数名。可以传文件路径：

3.3pandas连接mysql，并读取数据

要实现 pandas 对 mysql 的读写需要三个库

pandas
sqlalchemy
pymysql

1、read_sql_query 读取 mysql

read_sql_query 或 read_sql 方法传入参数均为 sql 语句，读取数据库后，返回内容是 dateframe 对象。

import pandas
from sqlalchemy import create_engine

class mysqlconn:
    def __init__(self):
        mysql_username = 'root'
        mysql_password = '123456'
        # 填写真实数库ip
        mysql_ip = 'x.x.x.x'
        port = 3306
        db = 'work'
        # 初始化数据库连接,使用pymysql库
        self.engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}'.format(mysql_username, mysql_password, mysql_ip, port,db))

    # 查询mysql数据库
    def query(self,sql):
        df  = pandas.read_sql_query(sql,self.engine)
        # df = pandas.read_sql(sql,self.engine)     这种读取方式也可以

        # 返回dateframe格式
        return df

if __name__ =='__main__':
    # 查询的 sql 语句 
    SQL = '''select * from working_time order by id desc '''
    # 调用 mysqlconn 类的 query() 方法
    df_data = mysqlconn().query(sql=SQL)

2、to_sql 写入数据库

使用 to_sql 方法写入数据库之前，先把数据转化成 dateframe 。

import pandas
from sqlalchemy import create_engine

class mysqlconn:
    def __init__(self):
        mysql_username = 'root'
        mysql_password = '123456'
        # 填写真实数库ip
        mysql_ip = 'mysql.mall.svc.test.local'
        port = 3306
        db = 'work'
        # 初始化数据库连接,使用pymysql库
        self.engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}'.format(mysql_username, mysql_password, mysql_ip, port,db))

    # 查询mysql数据库
    def query(self,sql):
        df  = pandas.read_sql_query(sql,self.engine)
        # df = pandas.read_sql(sql,self.engine)

        # 返回dateframe格式
        return df

    # 写入mysql数据库
    def to_sql(self,table,df):
        # 第一个参数是表名
        # if_exists:有三个值 fail、replace、append
        # 1.fail:如果表存在，啥也不做
        # 2.replace:如果表存在，删了表，再建立一个新表，把数据插入
        # 3.append:如果表存在，把数据插入，如果表不存在创建一个表！！
        # index 是否储存index列
        df.to_sql(table, con=self.engine, if_exists='append', index=False)

if __name__ =='__main__':
    # 创建 dateframe 对象
    df = pandas.DataFrame([{'name':'小米','price':'3999','colour':'白色'},{'name':'华为','price':'4999','colour':'黑色'}])
    # 调用 mysqlconn 类的 to_sql() 方法
    mysqlconn().to_sql('phonetest',df)

3.4pandasl连接oracle，并去读数据

1、登录oracle
首先先导入sqlalchemy库的create_engine，

通过 engine = create_engine("dialect+driver://username:password@host:port/database")初始化连接

参数说明：

dialect，是数据库类型包括：sqlite, mysql, postgresql, oracle, mssql等
driver，指定连接数据库的API，如：`psycopg2``, ``pyodbc``, ``cx_oracle``等，为可选关键字。
username，用户名
password，密码
host，网络地址，可以用ip，域名，计算机名，当然是你能访问到的。
port，数据库端口。
database，数据库名称。

from sqlalchemy import   create_engine 
engine = create_engine("oracle://scott:tiger@hostname/dbname",encoding='utf-8', echo=True)

2、read_sql

pd.read_sql(sql, con, index_col=None, coerce_float=True, params=None, parse_dates=None, columns=None, chunksize=None)

参数说明：

sql，执行的sql，可为查询、删除、创建、更新等等的sql，在此可直接指定表名称，默认就是select * from tablename

con，指定的数据库连接，即con=engine，也就是我们刚才初始化的数据库连接engine

index_col，查询时，指定那一列为DataFrame的index，也可以是多列['a','b']，此时就生成了Multindex

coerce_float，boolean，默认为True，尝试转换float的值，用于设置sql查询的结果

params，list, tuple or dict, 可选关键字, 默认为:None，要传递给执行方法的参数列表。不太懂这个关键字，一般情况用不到

parse_dates， list or dict, 默认为 None，要解析为日期时间的字段

columns，查询时指定选择那些列，即select * from 中的*，默认全部列

chunksize，int，默认为None，如果指定数值，则返回一个迭代器，指定的数值为迭代器内数据的行数

3、to_sql

DataFrame.to_sql(self, name, con, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None)

关键参数说明：

name，数据库表名

con，指定的数据库连接，即con=engine，也就是我们刚才初始化的数据库连接engine

schema，指定样式，不明白有什么用处

if_exists，{'fail', 'replace', 'append'}, 默认为'fail'，即指定当数据库表存在时的处理方式，默认为fail，挂起一个错误

* fail: 挂起一个错误
* replace: drop掉原来的表，重新创建
* append: 在原来表基础上插入数据

index，boolean，默认为True，指定DataFrame的index是否一同写入数据库

index_label，在index关键字为True时，指定写入的index的字段名称，默认为None时，字段名称为index

chunksize，int，默认为None，如果指定数值，则返回一个迭代器，指定的数值为迭代器内数据的行数。当写入的数据量较大时，最好指定此关键字的数值

dtype，dict, 可选关键字，默认为None，即指定写入的字段字符类型，注意做好指定字符类型，因默认写入的数据类型数是colb，若没有指定数据类型，估计会报错。

4.数据查看

dates = pd.date_range('20210101', periods=20)
df = pd.DataFrame(np.random.randn(20, 4), index=dates, columns=list('ABCD'))

4.0显示设置

pd.set_option('display.max_rows',500)#设置展示最高行数
pd.set_option('display.max_columns',1000)#设置展示最高列数
pd.set_option('display.unicode.east_asian_width',True)#设置列名对齐
————————————————

4.1查看前几行数据

df.head()

4.2查看前几行数据

df.tail()

4.3查看dataframe的形状

df.shape

(20, 4)

4.4数据表基本信息（维度、列名称、数据格式、所占空间等）

df.info()

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 20 entries, 2021-01-01 to 2021-01-20
Freq: D
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   A       20 non-null     float64
 1   B       20 non-null     float64
 2   C       20 non-null     float64
 3   D       20 non-null     float64
dtypes: float64(4)
memory usage: 800.0 bytes

4.5每一列数据的格式

df.dtype

A    float64
B    float64
C    float64
D    float64
dtype: object

4.6某一列数据的格式

df['B'].dtype

dtype('float64')

4.7空值

df.isnull()

df.isna()

4.8某一列空值

df['B'].isnull()

df['B'].isna()

isna()和 isnull()区别：

isnan判断是否nan（not a number），一般是数值字段的null

isnull()主要是判断字符型是否有值，可以判断所有的空值，但是python的数值字段比如int float 为空的时候默认是Nan

可以看到isna()对，字符型空值不起作用

4.9查看列名称

df.columns

Index(['A', 'B', 'C', 'D', 'F'], dtype='object')

4.10查看索引

df.index

DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04',
               '2021-01-05', '2021-01-06', '2021-01-07', '2021-01-08',
               '2021-01-09', '2021-01-10', '2021-01-11', '2021-01-12',
               '2021-01-13', '2021-01-14', '2021-01-15', '2021-01-16',
               '2021-01-17', '2021-01-18', '2021-01-19', '2021-01-20'],
              dtype='datetime64[ns]', freq='D')

4.11查看某一列的唯一值

df['F'].unique()

array(['f', ''], dtype=object)

4.12查看统计信息

df.describe()

5.数据筛选

5.1布尔索引

df[df['F'] == 'f'] # 判断等式是否成立

5.2位置索引(iloc)

是根据行号来索引，行号从0开始，逐次加1

# 直接根据行号取值
df.iloc[1:2]

5.3标签索引(loc)

# 直接根据索引取值
df.loc["2021-01-02":"2021-01-02"]

# 使用布尔
df.loc[df['A']==2]

不同：
1. loc函数通过调用index名称的具体值来取数据
2. iloc函数通过行序号来取数据
3. 取多行数据时iloc不包含末尾
4. 对数据进行筛选使用loc函数，当使用loc函数时，如果index不具有特定意义，而且重复，那么提取的数据需要进一步处理,可用.reset_index()函数重置

5.4使用API

df.query('F=="f"')

# 多条件查询
df.query('A==1 | B==2')

6.常用函数

6.1窗口函数rolling()

DataFrame.rolling(window, min_periods=None, center=False, win_type=None, on=None, axis=0, closed=None)

window:时间窗的大小,数值int,即向前几个数据(可以理解将最近的几个值进行group by)
min_periods:最少需要有值的观测点的数量,对于int类型，默认与window相等
center:把窗口的标签设置为居中,布尔型,默认False
win_type: 窗口的类型,截取窗的各种函数。字符串类型，默认为None
on: 可选参数,对于dataframe而言，指定要计算滚动窗口的列,值为列名
closed：定义区间的开闭，支持int类型的window,对于offset类型默认是左开右闭的即默认为right,可以根据情况指定为left、both等
axis：方向（轴）,一般都是0

# -*- coding:utf-8 -*-
import pandas as pd
import numpy as np

# 创建DF
df = pd.DataFrame(np.random.randint(5, size=(10, 2)), index=pd.date_range('1/1/2020', periods=10), columns=['A', 'B'])
# 将B列最近2个值相加并生成新列
df['C'] = df['B'].rolling(window=2).sum()
# 将B列最近5个值相加并生成新列
df['D'] = df['B'].rolling(window=5).sum()

# 将B列最近2个值求平均并生成新列
df['E'] = df['B'].rolling(window=2).mean()
# 将B列最近5个值求平均并生成新列
df['F'] = df['B'].rolling(window=5).mean()

print(df)

A B C D E F
2020-01-01 4 0 NaN NaN NaN NaN
2020-01-02 4 1 1.0 NaN 0.5 NaN
2020-01-03 1 4 5.0 NaN 2.5 NaN
2020-01-04 2 2 6.0 NaN 3.0 NaN
2020-01-05 0 1 3.0 8.0 1.5 1.6
2020-01-06 2 1 2.0 9.0 1.0 1.8
2020-01-07 4 1 2.0 9.0 1.0 1.8
2020-01-08 3 0 1.0 5.0 0.5 1.0
2020-01-09 3 4 4.0 7.0 2.0 1.4
2020-01-10 3 3 7.0 9.0 3.5 1.8

常用聚合函数：

mean() 求平均
count() 非空观测值数量
sum() 值的总和
median() 值的算术中值
min() 最小值
max() 最大
std() 贝塞尔修正样本标准差
var() 无偏方差
skew() 样品偏斜度（三阶矩）
kurt() 样品峰度（四阶矩）
quantile() 样本分位数（百分位上的值）
cov() 无偏协方差（二元）
corr() 相关（二进制）

7.数据排序

Pandas 支持三种排序方式，按索引标签排序，按列里的值排序，按两种方式混合排序。

7.1 按索引标签排序

Series.sort_index() 与 DataFrame.sort_index() 方法用于按索引层级对 Pandas 对象排序。

7.2 按值排序

Series.sort_values()方法用于按值对 Series 排序。

‘DataFrame.sort_values() 方法用于按行列的值对 DataFrame 排序。

DataFrame.sort_values() 的可选参数 by 用于指定按哪列排序，该参数的值可以是一列或多列数据。

这些方法支持用 na_position 参数处理空值。

na_position='first'（空置排在前面）

7.3 混合排序

通过参数 by 传递给 DataFrame.sort_values()的字符串可以引用列或索引层名。

7.4搜索排序

Series 支持 searchsorted() 方法，这与numpy.ndarray.searchsorted() (opens new window)的操作方式类似。

7.5最大值与最小值

df.loc[:,'A'].nsmallest(3)

2021-01-01    0
2021-01-02    0
2021-01-03    0
Freq: D, Name: A, dtype: int64

df.loc[:,'A'].nlargest(3)

2021-01-07    1
2021-01-08    1
2021-01-12    1
Name: A, dtype: int64

8.数据拼接

9.数据聚合

10.时间日期

11.函数应用

管是为 Pandas 对象应用自定义函数，还是应用第三方函数，都离不开以下三种方法。用哪种方法取决于操作的对象是 DataFrame，还是 Series ；是行、列，还是元素。

表级函数应用：pipe()
行列级函数应用： apply()
聚合 API： agg() 与 transform()
元素级函数应用：applymap()

1、表级函数应用

虽然可以把 DataFrame 与 Series 传递给函数，不过链式调用函数时，最好使用 pipe()方法。对比以下两种方式：

# f、g、h 是提取、返回 `DataFrames` 的函数
>>> f(g(h(df), arg1=1), arg2=2, arg3=3)

>>> (df.pipe(h)
...    .pipe(g, arg1=1)
...    .pipe(f, arg2=2, arg3=3))

2、行列级函数应用

apply() 方法沿着 DataFrame 的轴应用函数，比如，描述性统计方法，该方法支持 axis 参数。

 df.iloc[:,:4].apply(np.mean)

A    0.300000
B   -0.054087
C    0.117827
D    0.020045
dtype: float64

df.iloc[:,:4].apply(np.mean, axis=1)

2021-01-01   -0.035445
2021-01-02   -0.713445
2021-01-03    0.081043
2021-01-04    0.002215
2021-01-05   -0.259167
2021-01-06    0.093416
2021-01-07   -0.190826
2021-01-08   -0.305420
2021-01-09   -0.024411
2021-01-10    0.486128
2021-01-11    0.303144
2021-01-12    0.186884
2021-01-13    0.325273
2021-01-14    0.397488
2021-01-15    0.478969
2021-01-16    0.247686
2021-01-17    0.351837
2021-01-18    0.650051
2021-01-19    0.071887
2021-01-20   -0.228385
Freq: D, dtype: float64

apply()方法还支持通过函数名字符串调用函数。

df.iloc[:,:4].apply('mean')

A    0.300000
B   -0.054087
C    0.117827
D    0.020045
dtype: float64

df.iloc[:,:4].apply('mean',axis=1)

2021-01-01   -0.035445
2021-01-02   -0.713445
2021-01-03    0.081043
2021-01-04    0.002215
2021-01-05   -0.259167
2021-01-06    0.093416
2021-01-07   -0.190826
2021-01-08   -0.305420
2021-01-09   -0.024411
2021-01-10    0.486128
2021-01-11    0.303144
2021-01-12    0.186884
2021-01-13    0.325273
2021-01-14    0.397488
2021-01-15    0.478969
2021-01-16    0.247686
2021-01-17    0.351837
2021-01-18    0.650051
2021-01-19    0.071887
2021-01-20   -0.228385
Freq: D, dtype: float64

默认情况下，apply()调用的函数返回的类型会影响 DataFrame.apply 输出结果的类型。

函数返回的是 Series 时，最终输出结果是 DataFrame。输出的列与函数返回的 Series 索引相匹配。
函数返回其它任意类型时，输出结果是 Series。

result_type 会覆盖默认行为，该参数有三个选项：reduce、broadcast、expand。这些选项决定了列表型返回值是否扩展为 DataFrame。

apply()有一个参数 raw，默认值为 False，在应用函数前，使用该参数可以将每行或列转换为 Series。该参数为 True 时，传递的函数接收 ndarray 对象，若不需要索引功能，这种操作能显著提高性能。

3、聚合 API

聚合 API 可以快速、简洁地执行多个聚合操作。Pandas 对象支持多个类似的 API，如 groupby API、window functions API、resample API 。聚合函数为DataFrame.aggregate() ，它的别名是 DataFrame.agg() 。

1AGG

单函数聚合

应用单个函数时，该操作与 apply() 等效，这里也可以用字符串表示聚合函数名。下面的聚合函数输出的结果为 Series：

df.iloc[:,:4].agg(np.mean)

A    0.300000
B   -0.054087
C    0.117827
D    0.020045
dtype: float64

df.iloc[:,:4].agg(np.mean,axis=1)

2021-01-01   -0.035445
2021-01-02   -0.713445
2021-01-03    0.081043
2021-01-04    0.002215
2021-01-05   -0.259167
2021-01-06    0.093416
2021-01-07   -0.190826
2021-01-08   -0.305420
2021-01-09   -0.024411
2021-01-10    0.486128
2021-01-11    0.303144
2021-01-12    0.186884
2021-01-13    0.325273
2021-01-14    0.397488
2021-01-15    0.478969
2021-01-16    0.247686
2021-01-17    0.351837
2021-01-18    0.650051
2021-01-19    0.071887
2021-01-20   -0.228385
Freq: D, dtype: float64

Series 单个聚合操作返回标量值：

df.loc[:,'A'].agg('sum')

多函数聚合

还可以用列表形式传递多个聚合函数。每个函数在输出结果 DataFrame 里以行的形式显示，行名是每个聚合函数的函数名。

df.iloc[:,:4].agg(['sum', 'mean'])

df.iloc[:,:4].agg(['sum', 'mean'],axis=1)

Series 聚合多函数返回结果还是 Series，索引为函数名：

df.loc[:,'A'].agg(['sum', 'mean'])

sum     6.0
mean    0.3
Name: A, dtype: float64

传递 lambda 函数时，输出名为 <lambda> 的行：

df.loc[:,'A'].agg(['sum', lambda x: x.mean()])

sum         6.0
<lambda>    0.3
Name: A, dtype: float64

应用自定义函数时，该函数名为输出结果的行名：

def mymean(x):
    return x.mean()


df.loc[:,'A'].agg(['sum', mymean])

sum       6.0
mymean    0.3
Name: A, dtype: float64

用字典实现聚合

指定为哪些列应用哪些聚合函数时，需要把包含列名与标量（或标量列表）的字典传递给 DataFrame.agg。

注意：这里输出结果的顺序不是固定的，要想让输出顺序与输入顺序一致，请使用 OrderedDict。

df.agg({'A': 'mean', 'B': 'sum'})

A    0.300000
B   -1.081742
dtype: float64

输入的参数是列表时，输出结果为 DataFrame，并以矩阵形式显示所有聚合函数的计算结果，且输出结果由所有唯一函数组成。未执行聚合操作的列输出结果为 NaN 值：

df.agg({'A': ['mean', 'min'], 'B': 'sum'})

多种数据类型（Dtype）

与 groupby 的 .agg 操作类似，DataFrame 含不能执行聚合的数据类型时，.agg 只计算可聚合的列(数值，字符串等类型)

2Transform API

transform()方法的返回结果与原始数据的索引相同，大小相同。与 .agg API 类似，该 API 支持同时处理多种操作，不用一个一个操作。

这里转换的是整个 DataFrame。.transform() 支持 NumPy 函数、字符串函数及自定义函数。

df.iloc[:,:4].transform(np.abs)
df.iloc[:,:4].transform('abs')
df.iloc[:,:4].transform(lambda x: x.abs())

.transform() 向 Series 传递单个函数时，返回的结果也是单个 Series。

多函数 Transform

transform() 调用多个函数时，生成多层索引 DataFrame。第一层是原始数据集的列名；第二层是 transform() 调用的函数名。

df.iloc[:,:4].transform([np.abs, lambda x: x + 1])

用字典执行 transform 操作

df.iloc[:,:4].transform({'A': np.abs, 'B': lambda x: x + 1})

transform() 的参数是列表字典时，生成的是以 transform() 调用的函数为名的多层索引 DataFrame。

4、元素级函数应用

并非所有函数都能矢量化，即接受 NumPy 数组，返回另一个数组或值，DataFrame 的 applymap()及 Series 的 map()，支持任何接收单个值并返回单个值的 Python 函数。

Series.map() 还有个功能，可以“连接”或“映射”第二个 Series 定义的值。这与 merging / joining 功能联系非常紧密：

12.变形操作

重塑（stack,unstack）
透视表与逆透视
哑变量与因子化

12.1重塑（stack,unstack）

stack: 将数据的列columns转旋转成行index
unstack：将数据的行index旋转成列columns
二者默认操作的都是最内层

stack

stack函数的主要作用是将原来的列转成最内层的行索引，转换之后都是多层次索引。

stack()即“堆叠”，作用是将列旋转到行

result = df.stack()
result

2021-01-01  A           0
            B   -0.067474
            C    1.358357
            D   -1.432663
            F           f
                   ...   
2021-01-20  A           0
            B   -1.106931
            C   -0.762231
            D     0.95562
            F           f
Length: 100, dtype: object

stack操作后将列索引旋转为行索引，并且置于行索引的最内层（外层为原索引），也就是将旋转轴的结果置于最低级别。

pd.stack(level=-1, dropna=True)

#模拟数据
multicol2 = pd.MultiIndex.from_tuples([('weight', 'kg'),  # 多层次列属性
                                       ('height', 'm')],
                                     name=["col","unit"])

data1 = pd.DataFrame([[1.0, 2.0], [3.0, 4.0]],
                     index=['cat', 'dog'],
                     columns=multicol2
                    )

data1

data1.stack()#默认最内层，

data1.stack(0)#

还可以同时对多个进行操作，指定名称或者索引号：
data1.stack([0,1])

参数dropna

#生成测试数据
data2 = pd.DataFrame([[None, 2.0],  # 引入一个缺失值
                      [4.0, 6.0]],
                     index=['cat', 'dog'],
                     columns=multicol2)
data2

data2.stack()#默认为True

data2.stack(dropna = False)#False，会保留同时为NaN的数据：

unstack()即stack()的反操作，将行旋转到列

unstack操作默认将内层索引number旋转为列索引。
同时，也可以指定分层级别或者索引名称来指定操作级别。

unstack(level=- 1, fill_value=None)

level：进行操作的索引层级，可以是名称
fill_value：当我们进行操作的时候，如果产生了缺失值，可以用指定的值填充

参数level

data3.unstack()#默认最内层

data3.unstack(0)#可以用参数科名称选索引

参数fill_value

该参数的作用是当我们使用unstack进行操作的时候，产生的缺失值用指定数据填充。

对产生的缺失值进行填充：

默认情况的使用
使用名称
使用索引号

12.2透视表与逆透视

1.pivot()

df.pivot(index=, columns=, values=)

index是重塑的新表的索引名称

columns是重塑的新表的列名称

values就是生成新列的值，如果没有，则会对dataframef剩下未统计的列进行重新排列放到columns的上层

#测试数据
df = pd.DataFrame({'foo': ['one','one','one','two','two','two'],
                       'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
                       'baz': [1, 2, 3, 4, 5, 6]})

df.pivot(index='foo', columns='bar', values='baz')

pandas.pivot行与列的交叉点值的索引应该是唯一值，如果不是唯一值，则会报错：

#测试数据
df1 = pd.DataFrame({'foo': ['one','one','one','one','two','two'],
                       'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
                       'baz': [1, 2, 3, 4, 5, 6]})

df1.pivot(index='foo', columns='bar', values='baz')
ValueError: Index contains duplicate entries, cannot reshape

2.pivot_table

pivot_table(data, values=None, index=None, columns=None,aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')

参数 Index

每个pivot_table必须拥有一个index：

pd.pivot_table(df,index=[u'foo'])

可以存在多个index

pd.pivot_table(df,index=[u'foo',u'bar'])

参数values

values可以对需要的计算数据进行筛选

pd.pivot_table(df,index=[u'foo',u'bar'],values=[u'baz'])

aggfunc

aggfunc参数可以设置对数据聚合时进行的函数操作。

pd.pivot_table(df,index=[u'foo',u'bar'],values=[u'baz'],aggfunc=[np.sum])

columns

Columns类似Index可以设置列层次字段，它不是一个必要参数，作为一种分割数据的可选方式。

pd.pivot_table(df,index=[u'foo'],values=[u'baz'],aggfunc=[np.sum],columns=u'bar')

3.melt

pandas.melt(dataframe,
                   id_vars=None, value_vars=None,
                   var_name=None,value_name=‘value’,
                   col_level=None)

frame ：就是指我们要操作的DataFrame;
id_vars : 就是我们自行指定哪些列作为identifier variables；
可以为tuple, list, or ndarray, optional Column(s)等
value_vars：指定哪些列被unprivot，我觉得就是把列转化为一行一行的键值对
可以为tuple, list, or ndarray, optional Column(s)等
var_name：给varivale那一列的别名。如果没指定或者为None，那么则默认为frame.columns.name 或者varivale
value_name：给value那一列的别名。默认为value
col_level：


df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},
                   'B': {0: 1, 1: 3, 2: 5},
                   'C': {0: 2, 1: 4, 2: 6}})

pd.melt(df, id_vars=['A'], value_vars=['B'])

pd.melt(df, id_vars=['A'], value_vars=['B','C'])

12.3哑变量与因子化

13.重复值操作

14.排名操作(rank)

DataFrame.rank(axis=0, 
               method='average', 
               numeric_only=None, 
               na_option='keep', 
               ascending=True, 
               pct=False)

axis：表示排名是根据哪个轴，axis=0表示横轴，axis=1表示纵轴

method：取值可以为'average'，'first'，'min'， 'max'，'dense'；后面重点介绍，默认是average

numeric_only：是否仅仅计算数字型的columns

na_optiaon：NaN值是否参与排名以及如何排名，取值为keep、top、bottom

ascending：升序还是降序；默认是升序

pct：是否以排名的百分比显示排名；所有排名和最大排名的百分比