Python：识别数据框列中的断点

Question

I am interested in identifying when different trips take place in a dataset. There are two lock states, where lock means the vehicle is stationary and unlocked means that the vehicle is being used.

As the same vehicle could be used by the same user multiple times, I first isolate the vehicle and a unique user through IDs and from a chronologically sorted time date column I can see when the vehicle was used. In order to identify different trips taken in the same vehicle by the same user I thought of identifying through my lock_state variable.

I've been trying to find how this could be done and percolation is something I came across but it seems too complex to understand and implement. I was wondering if there is an easier way of achieving this.

My end goal is to identify the number of trips (should be 2 in this example), add them to a new df alongside the user id and start/end datetimes (let's pretend all of this is the random column) and give them unique IDs. So the final output should be something like this (random made-up example):

trip_id      star_time  end_time user_id
jk3b4334kjh  x           x       093723
nbnmvn829nk  x           x       234380

Assuming the following sample data is in chronological order, how could I identify through the variable state different trips? (there should be 2 trips identified as the array is under continuous "unlocked" state twice before being interrupted by a "locked" state).

lock_state = ["locked", "unlocked", "unlocked", "unlocked", "locked", "locked", "unlocked", "unlocked"]
# should be 2 trips

random_values = random.sample(range(2,20), 8) 

df = pd.DataFrame(
    {'state': lock_state,
     'random': random_values
    })

df

>>
    state   random
0   locked      5
1   unlocked    12
2   unlocked    17
3   unlocked    13
4   locked      18
5   locked      6
6   unlocked    4
7   unlocked    9

Answer 1

shift your state column by 1 row; compare against the original, and filter on state "unlocked". Those identifies runs of consecutive "unlocked" states. The shift-compare portion is

df.state.eq(df.state.shift())

Given that hint, I expect that you can finish the coding, eh?

Answer 2

I came up with this implementation of a 1D Hoshen-Kopelman cluster labelling.

import random
import pandas as pd
import numpy as np

lock_state = ["locked", "unlocked", "unlocked", "unlocked", "locked", "locked", "unlocked", "unlocked"]

random_values = random.sample(range(2,20), 8) 

df = pd.DataFrame(
    {'state': lock_state,
     'random': random_values
    })
    

def hoshen_kopelman_1d(grid, occupied_label):
    """
    Hoshen Kopelman implementation for 1D graphs.
    
    Parameters:
            grid (pd.DataFrame): The 1D grid. 
            ocuppied_label (str): the label that identifies occupied nodes.

    Returns:
            labeled_grid (pd.DataFrame): grid with cluster labeled nodes.
    """
    
    # create labeled_grid and assign all nodes to cluster 0
    labeled_grid = df.assign(cluster=0)
    cluster_count = 0
    
    # iterate through the grid's nodes left to right
    for index, node in grid.iterrows():
        # check if node is occupied
        if node["state"] == occupied_label: # node is occupied
            if index == 0:
                # initialize new cluster
                cluster_count += 1
                labeled_grid.loc[0, "cluster"] = cluster_count
            else:
                # check if left-neighbour node is occupied
                if labeled_grid.loc[index-1, "cluster"] != 0: # left-neighbour node is occupied
                    # assign node to the same cluster as left-neighbour node
                    labeled_grid.loc[index, "cluster"] = labeled_grid.loc[index-1, "cluster"]
                else: # left-neighbour node is unoccupied
                    # initialize new cluster
                    cluster_count += 1
                    labeled_grid.loc[index, "cluster"] = cluster_count
                    
    return labeled_grid
                

M = hoshen_kopelman_1d(grid=df, occupied_label="unlocked")

It returns a new pandas.DataFrame with an extra "cluster" column, which indicates the cluster to which the node belongs ( 0 means the node is unoccupied and does not belong to any cluster).

Having this, it becomes pretty straightforward to retrieve the rows from, eg, trip 1 . We could do

trip_1 = M.loc[M['cluster'] == 1]