pandas的apply函数常见用法总结

对DataFrame的每一行执行一些复杂的操作

举一个例子，计算DataFrame中每一条数据中两个人的轨迹相似度，因为和业务相关，里面的子函数不能透露，这里重点呈现apply的用法。

import numpy as np

def calculate_trajectory_similarity(df, trail_dict):
"""

    :param trail_dict:
    :param df:
    :return:
"""
    body_threshold = 2
    similarity_threshold = 0.6
    insert_columns = [
        'trajectory_similarity',
    ]
    for c in insert_columns:
        try:
            #
            df.insert(df.shape[1], c, 0)
        except ValueError as v:
            #
            print(str(v))

    def calc_trajectory_similarity(element):
        """计算XXX"""
        trail01 = trail_dict.get(element['record_id1'])
        trail02 = trail_dict.get(element['record_id2'])
        trail_arr1 = np.array(trail01)
        trail_arr2 = np.array(trail02)
        face_trail01 = trail_arr1[trail_arr1[:, -1] == 'face']
        body_trail01 = trail_arr1[trail_arr1[:, -1] == 'body']
        face_trail02 = trail_arr2[trail_arr2[:, -1] == 'face']
        body_trail02 = trail_arr2[trail_arr2[:, -1] == 'body']
        sub_trail_list = [
            (face_trail01, face_trail02),
            (face_trail01, body_trail02),
            (body_trail01, face_trail02),
            (body_trail01, body_trail02)
        ]
        #
        avg_body_width = (element['body_width1'] + element['body_width2']) / 2
        tr_similarity_list = []
        for s in sub_trail_list:
            coordinate_arr1, coordinate_arr2, time_overlap = get_real_time_coordinates(s[0], s[1])
            if time_overlap > 0:
                sub_similarity = trajectory_similarity(coordinate_arr1, coordinate_arr2, avg_body_width, body_threshold,
                                                       similarity_threshold)
            else:
                sub_similarity = 0
            tr_similarity_list.append((min(len(coordinate_arr1), len(coordinate_arr2)), sub_similarity))
        if len(tr_similarity_list) > 0:
            weights = [i[0] for i in tr_similarity_list]
            if np.sum(weights) > 0:  #
                tr_similarity = np.sum([w * s for w, s in tr_similarity_list]) / np.sum(weights)
            else:
                tr_similarity = 0
        else:
            tr_similarity = 0
        element['trajectory_similarity'] = tr_similarity
        return element

    df = df.apply(calc_trajectory_similarity, axis=1)
    return df

里面最核心的操作是 df = df.apply(calc_trajectory_similarity, axis=1)，这行代码通过apply调用了calc_trajectory_similarity这个函数，并按照行遍历DataFrame，利用每一行（Series对象）的一些字段信息，计算出轨迹相似度，并存储到DataFrame中。 get_real_time_coordinates和 trajectory_similarity分别是统计实时点和计算轨迹相似度的自定义函数，在这里可以不用关注。

对Series的每一个元素执行一些复杂操作

举个例子，现有一些原始的轨迹数据，需要进行预处理，可以针对需要处理的DataFrame字段(Series格式)单独进行操作。

import re

def split_to_int(element):
    """XXX"""
    if element:
        return list(map(int, re.findall(r"[\d]+", element)))
    else:
        element = []
        return element

def split_to_list(element):
    """XXX"""
    if element:
        element = list(re.findall(r"[\d]+", element))
        element = list(map(convert_time, element))
        return element
    else:
        element = []
        return element

def trail_string_processing(df):
"""

    :param df:
    :return:
"""
    #
    pd.set_option('mode.chained_assignment', None)
    trail_name = [
        'trail_left_top_x',
        'trail_left_top_y',
        'trail_right_btm_x',
        'trail_right_btm_y',
    ]
    for t in trail_name:
        df.loc[:, t] = df[t].apply(split_to_int)
    return df

def time_string_processing(df):
"""
    XXX
    :param df:
    :return:
"""
    # XXX
    pd.set_option('mode.chained_assignment', None)
    df.loc[:, 'trail_point_time'] = df['trail_point_time'].apply(split_to_list)
    #
    df.loc[:, 'shot_time'] = df['shot_time'].apply(
        lambda x: x.tz_convert('Asia/Shanghai').tz_localize(None) if x.tz else x)
    return df

在上面的代码中，每一个apply都是针对series执行的操作，apply里面的函数可以是自定义函数，也可以是lambda匿名函数。

对GroupBy对象执行一些复杂操作

举个例子，现有一个DataFrame需要按照某些字段进行分组，然后对分组后的对象执行一些操作，然后重构为新的DataFrame，这时可以通过apply来实现。

import pandas as pd

def merge_key_person_info(df):
"""
    XXXX
    :param df:
    :return:
"""

    def group_by_key_person(element):
        element = element.drop_duplicates(subset=['pvid', 'rel_pvid'])
        #
        key_person_code = element['key_person_code'].iloc[0]
        if key_person_code == 'tag_is_family':
            max_members_num = 6
        else:
            max_members_num = 11
        key_person_num = len(element['pvid'].iloc[0].split(','))
        num_k = max_members_num - key_person_num
        num_k = num_k if num_k > 1 else 1
        element = element.sort_values(by=['relation_score'], ascending=False).iloc[:num_k, :]
        #
        key_person_score = list(set(element['key_person_score'].values))
        rel_pvid_list = list(element['rel_pvid'].values)
        relation_code_list = list(element['relation_code'].values)
        relation_score_list = list(element['relation_score'].values)
        start_time_list = list(element['relation_info_start_time'].values)
        end_time_list = list(element['relation_info_end_time'].values)
        series_dict = {
            'pvid': element['pvid'].iloc[0],
            'corp_id': element['corp_id'].iloc[0],
            'key_person_code': element['key_person_code'].iloc[0],
            'key_person_score': key_person_score,
            'rel_pvid': rel_pvid_list,
            'relation_code': relation_code_list,
            'relation_score': relation_score_list,
            'relation_info_start_time': start_time_list,
            'relation_info_end_time': end_time_list
        }
        result = pd.Series(series_dict)
        return result

    #
    group_by_obj = df.groupby(by=['pvid', 'corp_id', 'key_person_code'])
    group_df = group_by_obj.apply(group_by_key_person).reset_index(drop=True)
    return group_df

有时候为了提升效率，一些涉及到大量数值计算的apply可以使用numpy的.apply_along_axis替代。

def calculate_speed_and_angle_similarity(parameters_df):
"""

    :param parameters_df:
    :return:
"""
    try:
        #
        parameters_df.insert(parameters_df.shape[1], 'angle_similarity', 0)
        parameters_df.insert(parameters_df.shape[1], 'speed_similarity', 0)
    except ValueError as v:
        #
        logger = my_logger()
        logger.info(str(v))

    def calc_angle_speed_similarity(element):
        """XXXX"""
        angle1 = element[35]
        angle2 = element[83]

        moving_speed1 = element[43]
        moving_speed2 = element[91]

        #
        angle_difference = abs(angle1 - angle2)
        if angle_difference >= 90:  #
            angle_similarity = 0
        else:
            angle_similarity = np.cos(abs(angle1 - angle2) / 180 * np.pi)
        element[102] = angle_similarity

        #
        slower_speed = min(moving_speed1, moving_speed2)
        faster_speed = max(moving_speed1, moving_speed2)
        speed_similarity = slower_speed / faster_speed
        element[103] = speed_similarity
        return element

    arr = parameters_df.values
    new_arr = np.apply_along_axis(calc_angle_speed_similarity, axis=1, arr=arr)
    parameters_df = pd.DataFrame(new_arr, columns=parameters_df.columns)
    return parameters_df

按照上述写法，虽然可以在一定程度上提升运行速度，但由于ndarray不支持字符串索引，对字段的操作只能按照序号来进行，很容易出错，代码可读性也比较差，不太推荐在复杂函数中使用，简单的计算用np.apply_along_axis会比较适合。

上面的代码都是一些模块的片段，只是用来展示apply的用法，因此无法跑通，请多包涵。为了信息安全，所有注释和细节代码都删除了。

Original: https://blog.csdn.net/Ray_awakepure/article/details/121778153
Author: Ray_awakepure
Title: pandas的apply函数常见用法总结

相关阅读

Title: Ubuntu安装TensorFlow详细过程

Title: Ubuntu安装TensorFlow详细过程

一、准备工作

虚拟机：Vmware Workstation 16 Pro（至少需要Windows10才能支持）
操作系统：Ubuntu-20.04.2.0

二、安装Anaconda

可以来到清华大学的镜像源找到自己喜欢的版本下载
下载地址：
https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/

我是在Ubuntu上面的Firefox浏览器下载的，下载的版本是这个：

虽然下载好了，但是下载的很慢很慢，老是断网，然后再重新点一下才可以下载，花了很长时间。不过好像可以在自己的Windows上面先下载，然后在拖到虚拟机上面，具体我也不知道应该怎么弄。

下载好以后把它丢到download文件夹（其他文件夹也行）里然后执行安装脚本，按照提示一路yes或者回车就可以。

bash Anaconda3-5.3.1-Linux-x86_64.sh

注意：在安装的过程中，有安装路径提示，请记住这个安装路径的提示，之后配置Anaconda环境需要用上。

这样，Anaconda就装上了：

但是还需要配置一下环境变量

sudo gedit ~/.bashrc

在最后一行中加入自己安装的anaconda下bin的路径：

export PATH="/home/zlt/anaconda3/bin:$PATH"

保存关闭文件后，使其生效：

source ~/.bashrc

看到这一步就大功告成啦~

三、安装Tensorflow

这里装的是CPU版的不是GPU版的哈哈哈。

为了利用Python的虚拟环境来进行更好地管理，先用conda新建一个python版本为3.6的虚拟环境。

conda create -n tensorflow python=3.6

激活虚拟环境

source activate tensorflow

安装tensorflow，找到了豆瓣源

pip install -i https://pypi.doubanio.com/simple/ tensorflow==1.3.0

四、验证Tensorflow是否安装成功

先看看自己的tensorflow版本，可以看到我安装版本的是1.3.0

pip list

导入一个tensorflow的模块来试试就可以了，记得一定还是要在虚拟环境下：

source activate tensorflow

每个版本的模块有不同的特点，报错不一定是安装出错，有可能是tensorflow版本不一致模块的用法不一样。
新建一个hello.py文件，输入以下代码保存，使用python来运行：

import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
sess = tf.Session()
print(sess.run(hello))

这样就没问题了，这一大串是在说numpy包版本有问题啥的。

五、总结

今天花了很多时间安装这个TensorFlow，遇到了很多问题，比如我之前下载的操作系统是Ubuntu16 ，我发现很多预安装在系统上面的软件都是版本很低的，比如Python只有2点几的版本，直接导致pip命令没办法使用，需要更新，更新了也有问题，还是用不了，于是我果断下载了Ubuntu20，很多命令就可以正常使用了。之前我的Linux操作系统这门课没有怎么好好学，现在又回来学这个，感觉还是力不从心，之后还得多练练才行。

Original: https://blog.csdn.net/ELSA001/article/details/119150775
Author: 钟良堂
Title: Ubuntu安装TensorFlow详细过程

Original: https://blog.csdn.net/ELSA001/article/details/119150775
Author: 钟良堂
Title: Ubuntu安装TensorFlow详细过程