Tratando de separar nombres y apellidos de un campo. Se separa el nombre completo por palabras, se procesa cada palabra, si es una palabra que forma parte de un nombre o apellido compuesto se guarda para anexarla hasta el siguiente ciclo. Al final se tiene que tomar una decisión sobre que hacer para separar los nombres si son más de dos. Si son …

separar_nombres_apellidos.php

<?php

  /* separar el nombre completo en espacios */
  $tokens = explode(' ', trim($full_name));
  /* arreglo donde se guardan las "palabras" del nombre */
  $names = array();
  /* palabras de apellidos (y nombres) compuetos */
  $special_tokens = array('da', 'de', 'del', 'la', 'las', 'los', 'mac', 'mc', 'van', 'von', 'y', 'i', 'san', 'santa');
  
  $prev = "";
  foreach($tokens as $token) {
      $_token = strtolower($token);
      if(in_array($_token, $special_tokens)) {
          $prev .= "$token ";
      } else {
          $names[] = $prev. $token;
          $prev = "";
      }
  }
  
  $num_nombres = count($names);
  $nombres = $apellidos = "";
  switch ($num_nombres) {
      case 0:
          $nombres = '';
          break;
      case 1: 
          $nombres = $names[0];
          break;
      case 2:
          $nombres    = $names[0];
          $apellidos  = $names[1];
          break;
      case 3:
          $apellidos = $names[0] . ' ' . $names[1];
          $nombres   = $names[2];
      default:
          $apellidos = $names[0] . ' '. $names[1];
          unset($names[0]);
          unset($names[1]);
          
          $nombres = implode(' ', $names);
          break;
  }
  
  $nombres    = mb_convert_case($nombres, MB_CASE_TITLE, 'UTF-8');
  $apellidos  = mb_convert_case($apellidos, MB_CASE_TITLE, 'UTF-8');

Muchas gracias Eduardo, adjunto la version como función en Python

def namesplit(name):
# Para convertir los Nombres y Apellidos
# Parametro esperado con nombre primero y apellidos despues
# Use https://gist.github.com/eduardoromero/8495437
tokens = name.split()
names = []
# Apellidos compuestos
special_tokens = ['da', 'de', 'del', 'la', 'las', 'los', 'mac', 'mc', 'van', 'von', 'y', 'i', 'san', 'santa']
prev=""
for token in tokens:
if token.lower() in special_tokens:
prev += token + " "
else:
names.append(prev+token)
prev=""

num_nombres = len(names)
nombres, apellidos = ("","")
if num_nombres == 0:
    return nombres, apellidos
elif num_nombres == 1:
    nombres = names[0]
    return nombres, apellidos
elif num_nombres == 2:
    nombres = names[0]
    apellidos = names[1]
    return nombres, apellidos
elif num_nombres == 3:
    nombres = names[0]
    apellidos = names[1] + " " + names[2]
    return nombres, apellidos
else:
    apellidos = names[num_nombres-2] + " " + names[num_nombres-1]
    names.pop()
    names.pop()
    nombres = " ".join(names)
    return nombres, apellidos

Muchas gracias por el aporte, hice una pequeña modificación en php (laravel) para el escenario donde se desea obtener el apellido paterno, apellido materno, primer nombre y segundo nombre por si alguien le interesa usándolo en un helpers y devolviendo en objeto.

// app/Helpers/FuncionesGenerales.php
function splitFullNameToIndividual($full_name)
{
/* Convierto a mayascula */
$full_name = Str::upper($full_name);

    /* separar el nombre completo en espacios */
    $tokens = Str::of($full_name)->trim()->explode(' ');
    /* arreglo donde se guardan las "palabras" del nombre */
    $names = array();
    /* palabras de apellidos (y nombres) compuetos */
    $special_tokens = array('DA', 'DE', 'DEL', 'LA', 'LAS', 'LOS', 'MAC', 'MC', 'VAN', 'VON', 'Y', 'I', 'SAN', 'SANTA');

    $prev = "";
    foreach ($tokens as $token) {
        $_token = $token;
        if (in_array($_token, $special_tokens)) {
            $prev .= "$token ";
        } else {
            $names[] = $prev . $token;
            $prev = "";
        }
    }
    $apellido_paterno = '';
    $apellido_materno = '';
    $primer_nombre = '';
    $segundo_nombre = '';
    $validar_name = true;

    $num_nombres = count($names);

    switch ($num_nombres) {
        case 0:
            break;
        case 1:
            $apellido_paterno = $names[0];
            break;
        case 2:
            $apellido_paterno = $names[0];
            $primer_nombre = $names[1];
            break;
        case 3:
            $apellido_paterno = $names[0];
            $apellido_materno = $names[1];
            $primer_nombre = $names[2];
            break;
        case 4:
            $apellido_paterno = $names[0];
            $apellido_materno = $names[1];
            $primer_nombre = $names[2];
            $segundo_nombre = $names[3];
            $validar_name = false;
            break;
        default:
            $apellido_paterno = "{$names[0]} {$names[1]}";
            $apellido_materno = $names[2];
            $primer_nombre = $names[3];

            unset($names[0], $names[1], $names[2], $names[3]);
            $segundo_nombre = implode(' ', $names);
            break;
    }

    return  ['apellido_paterno' => $apellido_paterno, 'apellido_materno' => $apellido_materno, 'primer_nombre' => $primer_nombre, 'segundo_nombre' => $segundo_nombre, 'validar_name' => $validar_name];
}

// En mi archivo donde lo estoy usando, lo obtengo con una Asignación de desestructuración.
['apellido_paterno' => $apellido_paterno, 'apellido_materno' => $apellido_materno, 'primer_nombre' => $primer_nombre, 'segundo_nombre' => $segundo_nombre, 'validar_name' => $validar_name] = splitFullNameToIndividual($full_name);

Excelente ejemplo! muchas gracias! tuve que pasarlo a .Net, en mi caso necesitaba hacerlo con primer nombre y segundo nombre, entonces esto resulte programando por sí a alguien puede servirle ;)

string nombres = $"Deybi";
string apellidos = $"Suanca";
char[] separador = { ' ' };

List<string> nombresLista = ExtractStrings(nombres, separador);
List<string> apellidosLista = ExtractStrings(apellidos, separador);

int num_nombres = nombresLista.Count();
int num_apellidos = apellidosLista.Count();
string primerNombre = "";
string segundoNombre = "";
string primerApellido = "";
string segundoApellido = "";
switch (num_nombres)
{
    case 0:
        primerNombre = "";
        segundoNombre = "";
        break;
    case 1:
        primerNombre = nombresLista[0];
        break;
    case 2:
        primerNombre = nombresLista[0];
        segundoNombre = nombresLista[1];
        break;
    default:
        break;
}

switch (num_apellidos)
{
    case 0:
        primerApellido = "";
        segundoApellido = "";
        break;
    case 1:
        primerApellido = apellidosLista[0];
        break;
    case 2:
        primerApellido = apellidosLista[0];
        segundoApellido = apellidosLista[1];
        break;
    default:
        break;
}

Console.WriteLine($"Primer nombre: {primerNombre}");
Console.WriteLine($"Segundo nombre: {segundoNombre}");
Console.WriteLine($"Primer apellido: {primerApellido}");
Console.WriteLine($"Segundo apellido: {segundoApellido}");

static List<string> ExtractStrings(string nombres, char[] separador)
{
    string[] tokens = nombres.Trim().Split(separador);
    string[] tokensEspeciales = { "da", "de", "del", "la", "las", "los", "mac", "mc", "van", "von", "y", "i", "san", "santa" };

    string prev = "";
    List<string> nombresLista = new List<string>();
    foreach (var item in tokens)
    {
        if (item != "")
        {
            string actual = item.ToLower();
            if (tokensEspeciales.Contains(actual))
            {
                prev = prev + actual.ToUpper() + " ";
            }
            else
            {
                nombresLista.Add(prev + item.ToUpper());
                prev = "";
            }
        }
    }

    return nombresLista;
}

Hola, he intentado modificar la función para Apps Script, ya que debo obtener por separado nombres y apellidos, algo como nombre1, nombre2, apellido1 y apellido2, pero no lo logro. Alguno ha implementado esta modificación de la función? o, alguien puede, por favor, ayudarme con esto?

aqui dejo una versión para python si contaramos con la CURP

import unicodedata

# Tokens compuestos comunes en nombres y apellidos
SPECIAL_TOKENS = {'da', 'de', 'del', 'la', 'las', 'los', 'mac', 'mc', 'van', 'von', 'y', 'i', 'san', 'santa'}

def normalizar(texto):
    return unicodedata.normalize('NFKD', texto).encode('ASCII', 'ignore').decode().upper()

def es_vocal(letra):
    return letra in "AEIOU"

def obtener_vocal_interna(nombre):
    for c in nombre[1:]:
        if es_vocal(c):
            return c
    return 'X'

def extraer_datos_desde_curp(curp):
    curp = curp.upper()
    return {
        'letra_apellido_paterno': curp[0],
        'vocal_interna_apellido_paterno': curp[1],
        'letra_apellido_materno': curp[2],
        'letra_nombre': curp[3],
    }

def separar_nombre_completo(nombre_completo: str, curp: str = None):
    tokens = nombre_completo.strip().split()
    tokens = [normalizar(t) for t in tokens]
    palabras = []

    # Une tokens compuestos
    prev = ""
    for token in tokens:
        if token.lower() in SPECIAL_TOKENS:
            prev += token + " "
        else:
            palabras.append((prev + token).strip())
            prev = ""

    # Inicializa variables
    apellido_paterno = apellido_materno = nombre = ""
    total = len(palabras)

    if total >= 3:
        apellido_paterno = palabras[0]
        apellido_materno = palabras[1]
        nombre = ' '.join(palabras[2:])
    elif total == 2:
        apellido_paterno = palabras[0]
        nombre = palabras[1]
    elif total == 1:
        nombre = palabras[0]

    # Validación con CURP
    if curp:
        curp_val = extraer_datos_desde_curp(curp)

        if apellido_paterno:
            if normalizar(apellido_paterno)[0] != curp_val['letra_apellido_paterno'] or \
               obtener_vocal_interna(normalizar(apellido_paterno)) != curp_val['vocal_interna_apellido_paterno']:
                print("⚠️ Advertencia: El apellido paterno no coincide con la CURP.")

        if apellido_materno and normalizar(apellido_materno)[0] != curp_val['letra_apellido_materno']:
            print("⚠️ Advertencia: El apellido materno no coincide con la CURP.")

        if nombre and normalizar(nombre)[0] != curp_val['letra_nombre']:
            print("⚠️ Advertencia: El nombre no coincide con la CURP.")

    return {
        'apellido_paterno': apellido_paterno.title(),
        'apellido_materno': apellido_materno.title(),
        'nombre': nombre.title()
    }