Agregando diccionarios a nuestro proyecto

Mi versión del código

import sys


clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Sofware Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    },
]

def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in client\'s list')

def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client['position']))


def ingress_client_data(): 
    client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position')
    }
    return client


def update_client(client_id, updated_client):
    global clients

    if len(clients) -1 >= client_id:                
        clients[client_id] = updated_client
    else:
        print('Client is not in clients list')


def delete_client(client_name):
    global clients

    if client_name in clients:
        clients.remove(client_name)
    else:
        print('Client is not in clients list')


def search_client(client_name):
    for client in clients:
        if client != client_name:
            continue
        else:
            return True


def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('What would yo like to do today?')
    print('[C]reated client')
    print('[U]pdate client')
    print('[L]ist clients')
    print('[D]elete client')
    print('[S]earch client')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}? '.format(field_name))

    return field


if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = ingress_client_data()
        create_client(client)
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif command == 'U':
        list_clients()
        client_id = int(_get_client_field('id'))
        updated_client = ingress_client_data()

        update_client(client_id, updated_client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found:
            print('The client is in the client\'s list')
        else :
            print('The client: {} is not in client\'s list'.format(client_name))
    else:
        print('Invalid command') 

import sys

clientes = [
    {
        'name': 'Juan',
        'company': 'Maxidespensa',
        'email' : '[email protected]',
        'position' : 'Sofware Engineer'
    },
    {
        'name': 'Pedro',
        'company': 'Google',
        'email' : '[email protected]',
        'position' : 'UX Designer'
    },
]

def create_client(client_name):
    global clientes
    if client_name not in clientes:
        clientes.append(client_name)
    else:
        print('Client alredy is in client\'s list')

def list_clients():
    for idx, cliente in enumerate(clientes):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=cliente['name'],
            company=cliente['company'],
            email=cliente['email'],
            position=cliente['position']

        ))

def update_client_search(client_name):
    global clientes
    indice = 0
    for idx in clientes:
        indice += 1
        for values in idx.values():
            if client_name == values:
                return indice - 1

def update_client(client_name, update_people):
    global clientes
    indice =  int(update_client_search(client_name))
    clientes [indice] = update_people

def searh_client(name):
    global clientes
    for idx in clientes:
        for persona in idx.values():
            if name == persona:
                return True
            else:
                False

def delete_client(client_name):
    global clientes
    if client_name in clientes:
        clientes.remove(client_name)
    else:
        print('Not Found Client')

def _print_welcome():
    print('Welcome To Platzi Ventas')
    print('*' * 50)
    print('What would yo like to day')
    print('[L]ist clients')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name):
    field = None
    while not field:
        field = input('What is the client {}?'.format(field_name))
    return field

def _get_client_name():
    client_name = None
    while not client_name:
        client_name = input('What is the client name? ')
        if client_name == 'exit':
            client_name = None
            break
    if not client_name:
        sys.exit()
    return client_name

if __name__ == "__main__":
    _print_welcome()

    commad = input()
    commad = commad.upper()
    if commad == 'C':
        client_name = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
        create_client(client_name)
        list_clients()
    elif commad == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()

    elif commad == 'U':
        client_name = _get_client_name()
        found = searh_client(client_name)
        if found:
            update_client_name = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
            update_client(client_name,update_client_name)
            list_clients()
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))

    elif commad == "S":
        client_name = _get_client_name()
        found = searh_client(client_name)
        if found:
            print("The client is in the list client\'s")
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))

    elif commad == 'L':
        list_clients()
    else:
        print('Command Invalid')```

¡Hola! El código de esta clase me generó varios conflictos porque estoy usando otras anotaciones y tengo algunas cositas añaditas mías, tuve más de 10 errores distintos al final de la clase, me llegó el pensamiento de ¿Y si esto no es para mí? Pero escuché la voz de Freddy diciendo “Lo que hacemos es dividir un gran problemas en problemas más pequeños”, luego de esa frase, logré encontrar rápidamente cada uno de los errores, así que si tú, estás cuestionando si deberías de seguir o no, quiero decirte que sí, sí puedes lograr lo que quieres, puedes cambiar ese empleo mal pago y que no te gusta, puedes crear ese emprendimiento en tecnología y puedes todavía mucho más, recuerda, un gran problema lo divides en pequeños problemas, yo creo en ti desconocid@.

Hay un detalle interesante en la función delete_client(client_id), esto es al tener activado el pylint, ya que me marca que la variable client (dentro del for) no se usa en ningún momento. La corrección, después de haber leído cómo resolverlo es la siguiente:

Esta es la versión con el error de pylint W0612:

def delete_client(client_id):
    global clients

    for idx, client in enumerate(clients): # pylint retorna un error W0612 Unnused variable
        if idx == client_id:
            del clients[idx]
            break

Esta es la versión corregida:

def delete_client(client_id):
    global clients

    for idx, dummy_client in enumerate(clients):
        if idx == client_id:
            del clients[idx]
            break

Según lo leído aquí, es necesario que a las variables que (por alguna razón) no se van a usar, se les anteceda con dummy (o _, aunque esta opción es la menos recomendada por las confusiones que pueda ocasionar por los identificadores semi-privados) en el nombre, y de este modo Python la reconoce como una variable que puede no utilizarse.

Saludos 👋

Reto cumplido

Funciones Auxiliares

def _get_index(client_name):
    global clients

    for idx, client in enumerate(clients):
        print(idx)
        if client['name'] == client_name:
            return idx

Funciones Principales

def update_client(updated_client_fields, index):
    global clients

    if index is not None:
        clients[index].update(updated_client_fields)
    else:
        _message_to(client_name, False)

Llamados

if __name__ == '__main__':
    _print_welcome()

    command = input().upper()


    if command == 'C':
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'job': _get_client_field('job'),
        }
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'U':
        client_name = input('Who do you want to update?: ')
        updated_client_fields = _set_update_fields()
        index = _get_index(client_name)
        update_client(updated_client_fields, index)
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        index = _get_index(client_name)
        delete_client(client_name, index)
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found:
            _message_to(client_name, True)
        else:
            _message_to(client_name, False)
    else:
        print('Invalid command')

¿Queréis que todos los valores de cada cliente empiecen por mayúscula?:

# Capitalize all the values of every client
for i in range(len(clients)):
    clients[i] = {k: v.capitalize() for k,v in clients[i].items()}

Incluirlo al inicio de list_clients() (después de global clients)

Tarea

import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Sofware Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    },
]

def create_client(client):

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'
        .format(uid=idx, 
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']))


def update_client(client_name):
    client = search_client(client_name)
    if client:
        print('****Udate to client*****')

        index = clients.index(client)
        clients[index] = _get_client_info()
    else:
        _no_clients_list()


def delete_client(client_name):
    client = search_client(client_name)
    if client:
        clients.remove(client)
    else:
        _no_clients_list()


def search_client(client_name):
    
    for client in clients:
        if client['name'].capitalize() != client_name.capitalize():
            continue
        else:
            return client
    
    return {}

def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)#imprimir 50 beces el asterisco
    print('What would you like to do doday?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


def _get_client_field(field_name):
    field = None
    
    while not field:
        field = input('What is the client {}?'.format(field_name))

    return field
    

def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('What is the client name? ')

        if client_name == 'exit':
            client_name = None
            break
        
    if not client_name:
        sys.exit()
        
    return client_name


def _get_client_info():
    return {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position')
    }


def _no_clients_list():
    return print('Client is not in client\'s list')

if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = _get_client_info()

        create_client(client)
        list_clients()
    elif command == 'D':
        client_name = _get_client_field("name")               

        delete_client(client_name)
        list_clients()
        pass
    elif command == 'U':
        client_name = _get_client_field("name")

        update_client(client_name)
        list_clients()
        pass
    elif command == 'S':
        client_name = _get_client_field("name")
        client = search_client(client_name)

        if client:
            print('The client: {} is in the client\'s list'.format(client_name))
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))

        list_clients()
        pass
    else:
        print('Invalid command')

    

Quizá fui un tanto redundante, pero lo sentí legible, aquí mi código y pues regalenme un like, si les agradó la solución.

import sys
clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position':'Software engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position':'Data engineer',
    }
]

def create_client(client):
    global clients #global permite jalar las variables globales del scoop

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client['position']))


def delete_client(client_name):
    for i in range(0, len(clients)):
        if client_name == clients[i]['name']:
            clients.remove(clients[i])
            break
        else:
            print('Client is not in clients list')


def update_client(client_name, updated_name, updated_data):
    for i in range(0, len(clients)):
        if client_name == clients[i]['name']:
            clients[i] = updated_data

    else:
        print('Client is not in clients list')


def search_client(client_name):
    for i in range(0, len(clients)):
        if client_name != clients[i]['name']:
            continue
        else:
            return True


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}? '.format(field_name))

    return field


def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('Whats is the client name? ')

        if client_name == 'exit':
            client_name = None
            break

    if not client_name:
        sys.exit()

    return client_name

def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[L]ist client')
    print('[D]elete client')
    print('[U]pdate client')
    print('[S]earch client')

if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
            }
        create_client(client)
        list_clients()

    elif command == 'L':
        list_clients()

    elif command == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()

    elif command == 'U':
        client_name = _get_client_name()
        updated_name = input('What is the updated client name?: ')

        updated_data = {
            'name': updated_name,
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
            }


        update_client(client_name, updated_name, updated_data)
        list_clients()

    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in the client\'s list'.format(client_name))

    else:
        print('invalid comand')

Mi codigo, le añadi un retoque a la funcipon Delete, para evitar errores, haciendo que el usuario confirme la eliminación

import sys

clients = [
    {
        'name' : 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position' : 'Sofware engineer'
    },
    {
        'name' : 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position' : 'Data engineer'
    }
]

def _get_client_field(field_name):
    field = None

    while not field:
        field = input(f'What is the client {field_name}?  ')

    return field

def create_client(client_name):
    global clients

    if client_name not in clients:
        clients.append(client_name)
    else: 
        print('Client already is in the client\'s list')

def update_client(update_client_name, client_name):
    global clients
    for client in clients:
        if updated_client_name in client['name']:
            name = client_name
            company = _get_client_field('company')
            email = _get_client_field('email')
            position = _get_client_field('position')
            client.update({'name' : name, 'company' :company, 'email': email, 'position': position})
        else:
            print('Client is not in clients list')

def delete_client(client_name):
    for client in clients:
        if client_name == client['name']:
            command = input(f'Are you sure you want to eliminate {client_name}?(Y/n) ')
            if command == 'Y':
                clients.remove(client)
            else:
                sys.exit()
        else:
            print('Client is not in clients list')


def seach_client(client_name):
    for client in clients:
        if client_name == client['name']:
            return True
    return False


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client ['position']
        ))

def _print_welcome():
    print('WELCOME TO QUEIS VENTAS')
    print('*' * 5)
    print('What wouls you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


if __name__ == '__main__':
    _print_welcome()

    command = input().upper()

    
    if command == 'C':
        client = {
            'name' : _get_client_field('name'),
            'company' : _get_client_field('company'), 
            'email' : _get_client_field('email'), 
            'position' : _get_client_field('position'), 
        }
        create_client(client)
        list_clients()
    elif command == 'D':
        client_name = _get_client_field('[D]eleted')

        delete_client(client_name)
        list_clients()
    elif command == 'U':
        updated_client_name = _get_client_field('to [U]pdate')
        client_name = _get_client_field('new')

        update_client(updated_client_name, client_name)
        list_clients()
    elif command == 'S':
        client_name = _get_client_field('[S]earch')
        found = seach_client(client_name)

        if found:
            print('The client is in the clien\'s list')
        else:
            print(f'The client: {client_name} is not in out client\'s list')

    else:
        print('Invalid Command')

Mi verisón de las funciones UPDATE, DELETE y SEARCH:
UPDATE:

def update_client(client_name):
    state = 0
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            a = '''Choose a number to define which field you will update:
            1) All of them
            2) Name
            3) Company
            4) Email
            5) Position
            : '''
            ask = int(input(a))

            if ask == 1:
                all_them = {
                    'name': _get_client_field('name'),
                    'company': _get_client_field('company'),
                    'email': _get_client_field('email'),
                    'position': _get_client_field('position'),
                }
                clients[idx] = all_them
            elif ask == 2:
                name = _get_client_field('name')
                clients[idx]['name'] = name
            elif ask == 3:
                company = _get_client_field('company')
                clients[idx]['company'] = company
            elif ask == 4:
                email = _get_client_field('email')
                clients[idx]['email'] = email
            elif ask == 5:
                position = _get_client_field('position')
                clients[idx]['position'] = position
        else:
            state = 1
    if state == 1:
        print('Client is not in clients list')

DELETE

def delete_client(client_name):
    state = 0
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            del clients[idx]
        else:
            state = len(clients)

    if state == len(clients):
        print('Client is not in clients list')

SEARCH:

 def search_client(client_name):
    for idx, client in enumerate(clients):
        if client_name != client['name']:
            continue
        else:
            return True

Solucion al reto, aunque en el Update no solo se actualizo el nombre sino toda la informacion

def update_client(client_name, updated_client):
  global clients
  for key, client in enumerate(clients):
    if client["name"] == client_name:
      clients[key] = updated_client
      break
  else:
    print("Client is not in the client's list")

def delete_client(client_name):
  global clients
  for key, client in enumerate(clients):
    if client["name"] == client_name:
      del clients[key]
      break
  else:
    print("Client is not in the client's list")

def search_client(client_name):
  for client in clients:
    if client['name'] == client_name:
      return True
  return False

# Actualizacion
client_name = _get_client_name()
    
    client = {
      "name": _get_client_field("name", is_new=True),
      "company": _get_client_field("company", is_new=True),
      "email": _get_client_field("email", is_new=True),
      "position": _get_client_field("position", is_new=True)
    }

    update_client(client_name, client)

import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'software engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'data engineer'
    }
]

def create_client(client):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            position=client['position']
        ))


def print_welcome():
    print('Welcome to platzi sales')
    print('*' * 50)
    print('What would you like doing today?')
    print('[C]reate client: ')
    print('[L]ist clients: ')
    print('[U]pdate client')
    print('[D]elete client: ')
    print('[S]earch client')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}: ?'.format(field_name))

        return field
        


def _get_client_name():
    client_name = None
    while not client_name:
        client_name = input('What is the client name? :')

        if client_name == 'exit':
            client_name = None
            break
    
    if not client_name:
        sys.exit()

    return client_name


def _get_message(kind_of_message):
    if kind_of_message == 'refuse' :
        return print('Client is not in clients list')
    elif kind_of_message == 'isInList':
        return print('This client name  is in the client list')
    elif kind_of_message == 'success':
        return print('success')

def update_client(client_name):
    global clients

    for client in clients:
        if client['name'] == client_name:
            index = clients.index(client)
            client = _get_client_object()

            clients[index] = client

def _delete_client(client_name):
    global clients

    for client in clients:
        if client['name'] == client_name:
            index = clients.index(client)
            clients.pop(index)
            _get_message('success')
            break
        else:
            _get_message('refuse')


def search_client(client_name):
    global clients
    for client in clients:
        if client['name'] != client_name:
            continue
        else:
            return True


def _get_client_object():
    client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position')
        }
    return client



if __name__ == '__main__':
    print_welcome()

    command = input().upper()

    if command == 'C':
        client = _get_client_object()
        
        # client_name = _get_client_name()
        create_client(client)
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        _delete_client(client_name)
        list_clients()

    elif command == 'U':
        client_name = _get_client_name()
        update_client(client_name)

        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found: 
            _get_message('isInList')
        else:
            print('The client {} is not our client\'s list'.format(client_name))

    else:
        print('Invalid comman')

<code>
import sys
#variable global
clients=[
    {
        'name': 'pablo',
        'company': 'google',
        'email': '[email protected]',
        'position': 'software engineer'
    },
    {
        'name': 'ricardo',
        'company': 'facebook',
        'email': '[email protected]',
        'position': 'data engineer'
    }
]



#crear cliente
def create_client(client_name):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print('client already is in client\'s list')



#Listar clintes
def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
        uid=idx,
        name = client['name'],
        company=client['company'],
        email=client['email'],
        position=client['position']
        ))



#optiene el campo del cliente
def _get_client_field(field_name):
    field = None

    while not field:
        field = input('what is the client {}?'.format(field_name))

    return field



#devuelve el indice del cliente
def _get_index_client():
    client_name=None
    client_index=None

    while not client_name:
        client_name=str(input('what is the client name? =>'))
        if client_name == 'exit':
            client_name=None
            break
    if not client_name:
        sys.exit()

    for idx, client in enumerate(clients):
        if client['name'] == client_name:
            client_index=idx

    return client_index



#recoge la opcion de update client
def _get_option():
    option=None
    while not option:
        option=str(input('=> ')).upper()
        if option == 'exit':
            option=None
            break
        elif option != 'N' and option != 'C' and option != 'E' and  option != 'P':
            print('Invalid command')
            option=None
    if not option:
        sys.exit()

    return option



#recoge nuevo valor
def _get_value():
    value = None
    while not value:
        value=str(input(' Enter new value => '))
        if value == 'exit':
            value=None
            break

    if not value:
        sys.exit()

    return value



#menu de opciones a actualizar
def _print_option():
    print("""Choose the option you want to modify
            [N]ame
            [C]ompany
            [E]mail
            [P]osition
            """)



#actualizar clientes
def update_client(client_index):
    global clients

    for idx, client in enumerate(clients):
        if idx == client_index:
            _print_option()
            option=_get_option()

            if option=='N':
                client['name']= _get_value()
                print('Name modified')

            elif option=='C':
                client['company']=_get_value()
                print('Company modified')

            elif option=='E':
                client['email']=_get_value()
                print('Email modified')

            elif option == 'P':
                client['position']=_get_value()
                print('Client modified')



#busca un cliente
def search_client():
    check = _get_index_client()
    return check



#borrar clientes
def delete_clients():
    global clients
    index = _get_index_client()
    if index != None:
            client=clients[index]
            print('client {} deleted'.format(client['name']))
            del clients[index]
    else:
        _get_not_client()



#muestra el menu
def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('what would you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[L]ist   client ')
    print('[D]elete client')
    print('[S]earch client')

#evita repetir codigo
def _get_not_client():
    return print('The client  is not in our Client\'s list')



#inicio main
if __name__ == '__main__':
    _print_welcome()

    command =str(input('=> ')).upper()

    if command == 'C':
        client = {
            'name': _get_client_field('name'),
            'company':_get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position')
        }
        create_client(client)
        list_clients()

    elif command =='D':
        delete_clients()
        list_clients()

    elif command =='U':
        client_index = _get_index_client()
        update_client(client_index)
        list_clients()

    elif command =='S':
        found = search_client()

        if found != None:
            print('The client is in the client\'s list')
            print(clients[found])
        else:
            _get_not_client()
    elif command == 'L':
        list_clients()

    else:
        print('Invalid command')

Bueno aqui mi codigo, espero les sirva de algo, Saludos !

import sys
clients=[
    {
        'name':'pablo',
        'company':'Google',
        'email':'[email protected]',
        'position':'Software Ingenier'
    },
    {
        'name':'Ricardo',
        'company':'Facebook',
        'email':'[email protected]',
        'position':'Data engineer'
    }

]



def _exist_client(client):
    global clients
    
    total_clientes=range(len(clients))
    for x in total_clientes:
        id=x
        if client['name'] in clients[x]['name']:
            return True,id
        else:
            continue
    return False,id


def create_client(client):
        clients.append(client)
    


def client_not_list():
    print('Client in not in clients list')


def list_clients():
    print('|id| |Name| |Company| |Email| |Position|')
    print('*'*50)
    for idx,client in enumerate(clients):
        
        print('{uid}|{name}|{company}|{email}|{position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'] 
        )
        )


def updated_client(client_name,updated_client_name,id):
    global clients
    clients[id]['name']=updated_client_name
    clients[id]['company']=_get_client_field('company')
    clients[id]['email']=_get_client_field('email')
    clients[id]['position']=_get_client_field('position')
    


def delete_client(id):
    global clients

    clients.pop(id)

  

def search_client(client):
    global clients
    
    total_clientes=range(len(clients))
    for x in total_clientes:
        if client['name'] in clients[x]['name']:
            id=x
            return True,x
        id=x
    return False,id

def _print_welcome():
    print('Welcome To Platzi Ventas')
    print('*'*50)
    print('What would you like to do today?')
    print('(C)reate client')
    print('(L)ist')
    print('(U)pdate client')
    print('(D)elete client')
    print('(S)earch client')

def _get_client_field(field_name):
    field =None

    while not field:
        field = input('What is the client {}?'.format(field_name))
    return field


def _get_client_name():
    client_name=None

    while not client_name:
        client_name=input('What is the Client name?')
        if client_name=='exit':
            client_name=None
            break
    
    if not client_name:
            sys.exit()

    return client_name



if __name__=='__main__':
    _print_welcome()
    command =input()
    command = command.upper();
    if command=='C':
    
        client={
            'name':_get_client_name()
        }
        TrueFalse,id=_exist_client(client)
        if TrueFalse==False:    
                client['company']=_get_client_field('company')
                client['email']=_get_client_field('email')
                client['position']=_get_client_field('position')
                create_client(client)
        else:
                print('Client already in the client\'s list')

        list_clients()
    elif command=='L':
        list_clients()
    elif command=='D':
        client_name={
            'name':_get_client_name()
        }
        TrueFalse,id=_exist_client(client_name)
        if TrueFalse==True:
            delete_client(id)
        else:
            print('The client: {} is not in our client\'s list'.format(client_name['name']))

        list_clients()
    elif command=='S':

        client_name={
        	'name':_get_client_name()
        	}

        TrueFalse,id=search_client(client_name)
        
        if TrueFalse==True:
            print('The client is in the client\'s list')
            print('{uid}|{name}|{company}|{email}|{position}'.format(
            uid=id,
            name=clients[id]['name'],
            company=clients[id]['company'],
            email=clients[id]['email'],
            position=clients[id]['position'] 
        	)
        	)
        else:
            print('The client: {} is not in our client\'s list'.format(client_name['name']))
            
    elif command =='U':
        client={
            'name': _get_client_name()
        }
        TrueFalse,id=_exist_client(client)
        if TrueFalse==False:
            client_not_list()
        else:
            updated_client_name=input('What is the updated client name ?')
            updated_client(client,updated_client_name,id)
            list_clients()
    else:
        print('Invalid command')```

<code>
import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Amazon',
        'email': '[email protected]',
        'position': 'Data engineer',
    }
]


def create_client(client):
    #se mete la variable client en la funcion
    global clients
    #si el cliente no esta en la lista de clientes:
    if client not in clients:
        clients.append(client)
    
    else:
        print('Client already is in the client\'s list ')

def list_clients():
    global clients

    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

def update_client(old_data, new_data):
    global clients
    
    for client in clients:
        for key, values in client.items():
                if old_data in values:    
                    for data in new_data:
                        clients.remove(client)
                        create_client(new_data)
                        return True

                else:
                    return False


def update_procces(field, old_data, new_data):
    cmd = update_client(old_data, new_data)
    if cmd is True:
        list_clients()            
    else:
        print(f'{field} not valid')



def delete_client(client_name):
    global clients
    
    for client in clients:
        for data in dicts.values():
            if client_name in data:
                clients.remove(client)
                return True
            
    

def search_client(client_name):
    global clients

    for client in clients:
        for data in client.values():
            if client_name == data:
                return True
            

def _print_welcome():
    print('\nBienvenidos a Platzi Ventas')
    print('+' * 27)
    print('What to do doing today?')
    print('[C]reate Client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[S]earch Client')
    print('[D]elete Client\n')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}? '.format(field_name))
    
    return field


def _get_client_field_updated(field_name):
    field = None

    while not field:
        field = input('What is the new client {}? '.format(field_name))
    
    return field



def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('What is the client name? ')
        
        if client_name.lower() == 'exit':
            client_name = None
            
    
    if not client_name:
        sys.exit()

    return client_name


if __name__ == "__main__":
    _print_welcome()

    command = input()
    if command.upper() == 'C':
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }

        create_client(client)
        list_clients()
    
    elif command.upper() == 'L':
        list_clients()

    elif command.upper() == 'D':
        client_name = _get_client_name()
        deleted = delete_client(client_name)
        if deleted is True:
            print('Deleted')
            list_clients()
        else:
            print('Client is not in the client\'s list')
        
        

    elif command.upper() == 'U':
        
        old_data = _get_client_field('name')
         
        new_data = {'name': _get_client_field_updated('name'),
                    'company': _get_client_field_updated('company'),
                    'email': _get_client_field_updated('email'),
                    'position': _get_client_field_updated('position'),
        }
        field = 'name'
            
        update_procces(field, old_data, new_data)
        


    elif command.upper() == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found:
            print('The Client is in the client\'s list')
        
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))
   
    else:
        print('Invalid command')

# -*- coding:utf-8 -*-

import sys


clients = [
	{
		'name': 'Pablo',
		'company': 'Google',
		'email': "[email protected]",
		"position": "Software engineer"
	},
	{
		'name': 'Ricardo',
		'company': 'Facebook',
		'email': '[email protected]',
		'position': 'Data engineer'
	}
]


def create_client(client):
	global clients

	if client not in clients:
		clients.append(client)
		print("The client {} has been created in our list.".format(client['name']))
		list_clients()
	else:
		print("The client {} is alredy registred.".format(client['name']))
		list_clients()


def delete_client(client_name):
	global clients
	found = None

	for idx, client in enumerate(clients):
		if client['name'] == client_name:
			clients.pop(idx)
			print("The client {} has been removed from our list.".format(client_name))
			list_clients()
			found = True
		else:
			found = False

	return found


def list_clients():
	print("This is our client list: ")
	for idx, client in enumerate(clients):
		print('{uid}: | {name} | {company} | {email} | {position} |'.format(
			uid=idx,
			name=client['name'],
			company=client['company'],
			email=client['email'],
			position=client['position']
			))
	print("*" * 50)


def search_client(client_name):
	found = None

	for idx, client in enumerate(clients):
		if client['name'] != client_name:
			found = False
			continue
		else:
			found = True
			break

	if found:
		print('The client {} is on our list, in the index {}.'.format(client_name, idx))
		list_clients()
	else:
		_not_client()

	return found


def update_client(client_name):
	found = search_client(client_name)

	if found is True:
		print("What data do you want to update? ")
		print("[N]ame?")
		print("[C]ompany?")
		print("[E]mail?")
		print("[P]osition?")
		print("*" * 50)

		field_update = input()
		field_update = field_update.upper()

		if field_update == "N":
			for idx, client in enumerate(clients):
				if client_name == client['name']:
					client['name'] = _get_client_field('name')
					list_clients()
		elif field_update == "C":
			for idx, client in enumerate(clients):
				if client_name == client['name']:
					client['company'] = _get_client_field('company')
					list_clients()
		elif field_update == "E":
			for idx, client in enumerate(clients):
				if client_name == client['name']:
					client['email'] = _get_client_field('email')
					list_clients()
		elif field_update == "P":
			for idx, client in enumerate(clients):
				if client_name == client['name']:
					client['position'] = _get_client_field('position')
					list_clients()
		else:
			print("Invalid command, try again.")

	else:
		_not_client()

	
def _print_wellcome():
	print("WELLCOME TO NEOPOLIX")
	print("*" * 50)
	print("What would you like to do today?")
	print("[C]reate Client")
	print("[D]elete Client")
	print("[L]ist Client")
	print("[S]earch Client")
	print("[U]pdate Client")
	print("*" * 50)


def _not_client():
	print("Client is Not in clients list")


def _get_client_field(field_name):
	field = None

	while not field:
		field = input('What is the client {}? '.format(field_name))

	return field


if __name__ == '__main__':
    _print_wellcome()


    command = input()
    command = command.upper()


    if command == "C":
    	client = {
    		'name': _get_client_field('name'),
    		'company': _get_client_field('company'),
    		'email': _get_client_field('email'),
    		'position': _get_client_field('position')
    	}
    	create_client(client)
    elif command == "L":
    	list_clients()
    elif command == "D":
    	client_name = _get_client_field('name')
    	delete_client(client_name)
    elif command == "U":
    	client_name = _get_client_field('name')
    	update_client(client_name)
    elif command == "S":
    	client_name = _get_client_field('name')
    	found = search_client(client_name)
    else:
    	print("Invalid command")

No sé qué sería de mi aprendizaje sin GPT. Que locura. Obvio dejo que me guie, tampoco que haga todo 🤣, por ejemplo no sabia porque del() no aparecía ni en la ayuda de lists ni de dict. y es porque es una built-in function jaja. Definitivamente aprendo más en los retos, solo contra el Código código 🐍🐧❤️

Aqui la parte del reto más importante:
Lo dejo listo para más adelante decirle al usuario que campo desea actualizar. Pero la del profe está muy genial, claro ya se reciben los parámetros como tal no hay que buscar nada solo validar.

Explicación Código update del profe:

The line if len(clients) - 1 >= client_id: checks if the given client_id is a valid index for the clients list. If it is, then the next line clients[client_id] = updated_client updates the information of the client at that index with the new information provided in the updated_client argument.

esta fue mi solucion para buscar un cliente

def searchclient(client_name):
global clients

filtrar = list(filter(lambda client: client['name'] == client_name, clients))
if filtrar == []: 
    print(f'client {client_name} not found')
else:
    print(filtrar)

y esta para eliminarlo

def deleteclient():
global clients

lits_clients()
delete = int(input('Enter the index of the client you want to delete -> '))
delete -= 1
clients.pop(delete) 
lits_clients()

Mi solución

"""Aplication CRUD in lists python"""
clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer  '
    },
    {
        'name': 'Luis',
        'company': 'Apple',
        'email': '[email protected]',
        'position': 'Frontend Developer'
    }
]

Create client:

def create_client(client):
    """create client"""
    global clients
    if client in clients:
        print(f'El cliente {client} ya está en la lista')
    else:
        clients.append(client)

List client:

def list_clients():
    """List clients"""
    for index, client in enumerate(clients):
        print(
            f"{index} {client['name']} {client['company']} {client['email']} {client['position']}")

Update client

def update_client(old_client, new_client):
    """Update client name"""
    global clients

    indice = None
    for index, item in enumerate(clients):

        if item['name'] == old_client:
            item['name'] = new_client
            break

    if indice is None:
        print(f'****El cliente {old_client} no está en la lista****')

Delete client

def delete_client(client):
    global clients

    indice = None
    for index, item in enumerate(clients):

        if item['name'] == client:
            indice = index
            break

    if indice is None:
        print(f'****El cliente {client} no está en la lista****')
    else:
        clients.pop(indice) 

Search client

def search_client(client):
    value = False
    for index, item in enumerate(clients):

        if item['name'] == client:
            value = True
            break
    return value

Get client:

def _get_client(key):
    client = None

    while not client:
        client = input(f'Ingrese el {key} del cliente?: ')
        if client == 'exit':
            client = None
            break
    return client

main

def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 30)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[R]ead client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


if __name__ == '__main__':
    _print_welcome()

    command = input(':').upper()

    if command == 'C':

        client = {
            'name': _get_client('name'),
            'company': _get_client('company'),
            'email': _get_client('email'),
            'position': _get_client('position')
        }

        create_client(client)
        list_clients()

    elif command == 'D':
        client = _get_client('name')
        delete_client(client)
        list_clients()

    elif command == 'R':
        list_clients()

    elif command == 'U':
        client_name = _get_client('name')
        new_client_name = input('Ingresa el nuevo nombre: ')
        update_client(client_name, new_client_name)
        list_clients()

    elif command == 'S':
        client_name = _get_client('name')
        found = search_client(client_name)
        list_clients()

        if found == True:
            print(f'****El cliente {client_name} se encuentra en la lista****')
        else:
            print(
                f'****El cliente {client_name} no se encuentra en la lista****')
    else:
        print('command invalid')

Para los que estén usando la sintaxis f-string se debe encerrar en comillas dobles o triples para que pueda funcionar.

def list_clients():
    for index, value in enumerate(clients):
        print(f"{index}: {value['name']}")

Mi versión del código

import os


#Creacion de una lista de diccionarios que da la facilidad de agregar
#   mayor cantidad detalles a cada elemento en la lista
clients = [
    {
        'name' : 'Pablo',
        'Company' : 'Google',
        'email' : '[email protected]',
        'position' : 'Software engineer',
    },

    {
        'name' : 'Ricardo',
        'Company' : 'Faceboo',
        'email' : '[email protected]',
        'position' : 'DB engineer',    
    }

]



def _get_client_field(field_name):
    field = None
    while not field:
        field = input('What\'s the client\'s {}?: '.format(field_name))
    return field



def _create_obj(_option):
    if _option == 1:
        client = {
                'name': _get_client_field('name').capitalize(),
                'Company' : _get_client_field('Company').capitalize(),
                'email' : _get_client_field('email'),
                'position' : _get_client_field('position').capitalize(),
            }
    else:
        client = {
            'name': _get_client_field('name').capitalize(),
        }
    return client



#This function is used to loop through the list easily
def _conversor_lists(client_d, aux):
    global clients
    num = int(len(clients))
    mlist = []
    pivot = []
    if client_d != None: 
        for idx in range(num):
            for content in clients[idx].values():
                mlist.append(content)
        for cont in client_d.values():
            pivot.append(cont)
        if aux == 0:
            return mlist #Full list
        else:
            return pivot # A small list with a name to search
    else:
        return None



def create_client(client):
    os.system("cls")
    print('\n\t --- NEW CLIENT ---\n')
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print('Client already in the client\'s list')



def delete_client(client_d):
    os.system("cls")
    print('\n\t --- DELETE CLIENT ---\n')
    global clients
    _return = search_client(client_d, 1, None)
    if _return != None:
        clients.pop(_return)
        print('Client {} was deleted successfully!\n'.format(client_d['name']))



def update_client(client_u):
    os.system("cls")
    print('\n\t --- CLIENT EDITION ---\n')
    global clients
    num = int(len(clients))
    _return = search_client(client_u, 1, None)
    _check = None
    if _return != None:
        while _check == None:
            print('Insert new information about the selected client: \n')
            client = _create_obj(1)
            _check = search_client(client,2,client_u)
        clients.insert(_return, client)
        clients.pop(_return+1)
        print('\t Update successful! \n')

    

def search_client(client_d, _var, cl_up):
    os.system("cls")
    if _var == 0: 
        print('\n\t --- SEARCHING CLIENT ---\n')
    global clients
    num = int(len(clients))
    mlist = _conversor_lists(client_d, 0)
    pivot = _conversor_lists(client_d, 1)
    pibot_up = _conversor_lists(cl_up, 1)
    num2 = int(len(mlist))
    a = 0
    for i in range(num2):
        if i%4 == 0 and i !=0:
            a+=1
        if pivot[0] == mlist[i]:
            if i == 0:
                if _var == 0:
                    print('\tCliente {} is in the list.\n'.format(client_d['name']))
                    for _key, value in clients[i-(a*3)].items():
                        print(str(_key) + ': ' + str(value) )
                    return None
                elif _var == 2: #Omitimos el nombre del cliente que se quiere editar
                    if pibot_up[0] != mlist[i]:
                        print('\t Two clients cannot exist with the same name...\n')
                        return None
                else:
                    return i-(a*3)
            else:
                if _var == 0: 
                    for _key, value in clients[i-(a*3)].items():
                        print(str(_key) + ': ' + str(value) )
                    return None
                else:
                    return i-(a*3)
            break
        elif i == num2-1 and _var != 2:
                print('Client {} doesn\'t exist in the list... \n'.format(client_d['name']))
                return None



def show_list():
    os.system("cls")
    print('\n\t --- CLIENT\'S LIST ---\n')
    for idx, client in enumerate(clients):
        print('Name: {}'.format(client['name']))
        print('Company: {}'.format(client['Company']))
        print('e-mail: {}'.format(client['email']))
        print('Possition: {} \n'.format(client['position']))



def _print_wellcome():
    print('-' * 50)
    menu = """
    What would you do today?

    1 - Create client
    2 - Delete client
    3 - Update client
    4 - Search client
    5 - Show clients
    6 - Exit

    Choose an option: """
    while True:
        try:
            option = int(input(menu))

            if option == 1:
                client = _create_obj(option)
                create_client(client)
                print('\n')
                show_list()
            elif option == 2:
                client_D = _create_obj(option)
                delete_client(client_D)
                print('\n')
            elif option == 3:
                client_u = _create_obj(option)
                update_client(client_u)
                print('\n')
            elif option == 4:
                client_S = _create_obj(option)
                search_client(client_S, 0, None)
            elif option == 5:
                show_list()
            elif option == 6:
                return 1
            else:
                print('Oops! That\'s not an option. Try again...\n')
        except ValueError:
                    print('Oops! That\'s not an option. Try again...\n')



def main():
    flag = 'y'
    exit_flag = 0
    while flag == 'y' or flag == 'Y':
        exit_flag = _print_wellcome()
        if exit_flag != 0:
            break
        flag = input('\tContinue? (y/n):')

    print('*' * 100)
    print('\t\t** END PROGRAM **')
   


if __name__ == '__main__':
    main()

RETO CUMPLIDO

import sys
clients = [
    {
        "name": "David",
        "company": "Facebook",
        "position": "Java Developer",
    },
    {
        "name": "Angeles",
        "company": "Canvas",
        "position": "Designer",
    }
]
"""var clients saves name of clients"""


def create_client(client):
    """this function add the name clients with the capital letter"""
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print("The client is already in the clients list")


def list_clients():
    """this function shows the clients list"""
    for index, client in enumerate(clients):
        uid=index
        name=client['name']
        company=client['company']
        position=client['position']
        print(f"{uid} | {name} | {company} | {position}")
            

def update_client(client_id, updated_client_name):
    """this function update data about clients"""
    global clients
    if len(clients) - 1 >= client_id:
        clients[client_id] = updated_client_name
    else:
        print("Client is not in the clients list")


def delete_client(client_id):
    global clients
    for idx, client in enumerate(clients):
        if idx == client_id:
            del clients[idx] 
            break
        else: 
            print("Client is not in the clients list")


def search_client(client_name):
    for client in clients:
        if client["name"] != client_name:
            continue
        else:
            return True


def _get_client_field(field_name):
    field = None
    while not field:
        field = input(f"What is the client {field_name}?")
    return field

def _get_client_name():
    client_name = None
    while not client_name:
        client_name = input("What is the client name? ")
        if client_name == "exit":
            client_name = None
            break
    if not client_name:
        sys.exit()
    return client_name


def _get_client_from_user():
    client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'position': _get_client_field('position'),}
    return client


def _print_welcome():
    """welcome message to clients"""
    print("Welcome to my store page:")
    print("*" * 100)
    print("What would you like to do today?")
    print("[C]reate client")
    print("[R]ead list of clients")
    print("[U]pdate client")
    print("[D]elete client")
    print("[S]earch client")


if __name__ == '__main__':
    _print_welcome()
    command = input().upper()
    if command == "C":
        client = _get_client_from_user()
        create_client(client)
        list_clients()
    elif command == "R":
        list_clients()
    elif command == "U":
        client_id = int(_get_client_field('id'))
        updated_client = _get_client_from_user()
        update_client(client_id, updated_client)
        list_clients()
    elif command == "D":
        client_id = int(_get_client_field('id'))
        delete_client(client_id)
        list_clients()
    elif command == "S":
        client_name = _get_client_name()
        found = search_client(client_name)
        if found:
            print("The client is in the clients list")
        else:
            print(f"the client: {client_name} is not in clients list")
    else: 
        print("Invalid command")

Aplique los principios de DRY y agregue la funcionalidad Read para completar el CRUD:

Ánimo, ya vamos a la mitad del curso
Si no entiendes bien lo de los diccionarios, mira los cursos de facundo aquí en Platzi

Wooooow me encanta, ahora es que se pone todo esto bueno

Esta es mi solucion 😃
import sys

clients = [
{
‘name’: ‘Pablo’,
‘company’: ‘Google’,
‘email’: ‘[email protected]’,
‘position’: ‘Software Engineer’,
},
{
‘name’: ‘Ricardo’,
‘company’: ‘Facebook’,
‘email’: ‘[email protected]’,
‘position’: ‘Data Engineer’,
},
]

def create_client(client):
global clients
if client not in clients:
clients.append(client)
else:
print(‘Client already is in the client’s list’)

def _get_client_field(field_name):
field=None

while not field:
    field=input('What is the client {}?'.format(field_name))

return field

def _get_client_data():
data={
‘name’:_get_client_field(‘name’),
‘company’: _get_client_field(‘company’),
‘email’: _get_client_field(‘email’),
‘position’: _get_client_field(‘position’),
}
return data
def _get_client_name():
client_name=None
while not client_name:
client_name=input('What is the client name? ')
if client_name==‘exit’:
client_name=None
break
if not client_name:
sys.exit()
return client_name.capitalize()

def list_clients():
global clients
print(‘uid | name | company | email | position ‘)
print(’*’ * 50)

for idx, client in enumerate(clients):
    print('{uid} | {name} | {company} | {email} | {position}'.format(
        uid=idx, 
        name=client['name'], 
        company=client['company'], 
        email=client['email'], 
        position=client['position']))

def update_clients(client_idx,update_client):
global clients
if client_idx<len(clients):
clients[client_idx]=update_client
else:
print=(‘Client is not in clients list’)
print( f’The client whit uid={client_idx} was update, the new list is:’)
list_clients()

def delete_client(idx):
global clients
if idx<len(clients):
clients.pop(idx)
else:
print(“The client whit this uid dont exixt”)

def _add_comma():
global clients
clients+=’,’

def search_client(client_name):
global clients
for client in clients:
if client!=client_name:
continue
else:
return True

def _print_welcome():
print(‘WELCOME TO PLATZI VENTAS’)
print(’*’*50)
print(‘What would you like to do today?’)
print(’[C]reate client’)
print(’[D]elite client’)
print(’[U]pdate client’)
print(’[S]earch client’)
print('This is the list: ')
list_clients()

if name == ‘main’:
_print_welcome()
command=input()
command=command.upper()

if command=='C':
    client=_get_client_data()
    create_client(client)
    print('This name was add')
    list_clients()
elif command=='R':
    list_clients()
elif command=='U':
    list_clients()
    client_idx=int(input('What is his uid?'))
    update_client=_get_client_data()
    update_clients(client_idx,update_client)
elif command=='D':
    list_clients()
    client_idx=int(input('What is his uid?'))
    delete_client(client_idx)
    print(f'The client whit uid={client_idx} was delite, the new list is:')
    list_clients()
elif command=='S':
    client_name=_get_client_name()
    found=search_client(client_name)
    if found:
        print(f'The client {client_name} is in the cient\'s list')
    else:
        print('The client:{} is not in client\'s list'.format(client_name))
else:
    print("Sorry, your response wasn't reciving")

import sys

clients = [
{
‘name’: ‘Pablo’,
‘company’: ‘Google’,
‘email’: ‘[email protected]’,
‘position’: ‘Software engineer’,
},
{
‘name’: ‘Ricardo’,
‘company’: ‘FaceBook’,
‘email’: ‘[email protected]’,
‘position’: ‘Data engineer’,
}
]

def _print_welcome():
print(‘Welcomo to Platzi Sales’)
print("*" * 50)
print(‘What would you like to do today.?’)
print(’[C]eate Client’)
print(’[L]ist Client’)
print(’[U]pdate Client’)
print(’[D]elete Client’)
print(’[S]earch Client’)

def create_client(client):
#global clients
if client not in clients:
clients.append(client)
else:
print(“Client already is in the client’s list”)

def _get_client():
client = {
‘name’: _get_client_field(‘name’),
‘company’: _get_client_field(‘company’),
‘email’: _get_client_field(‘email’),
‘position’: _get_client_field(‘position’),
}
return client

def list_clients():
for idx, client in enumerate(clients):
print(’{id} | {name} | {company} | {email} | {position}’
.format(
id = idx,
name = client[‘name’],
company = client[‘company’],
email = client[‘email’],
position = client[‘position’]
)
)

def _get_client_field(field_name, msg='What is the client {}.: '):
field = None
while not field:
field = input(msg.format(field_name))
return field

def update_client(updated_id):
global clients
if updated_id >= 0 and updated_id <= len(clients) -1:
clients[updated_id] = _get_client()
else:
print(‘The Id. {} not exist in the clients list’.format(updated_id))

def delete_client(client_id):
global clients
for idx, client in enumerate(clients):
if idx == client_id:
del clients[idx]
return print(idx)
else:
print(“The client Id {id} is not in clients list”.format(id=idx))

def search_client(client_name):
for client in clients:
if client[‘name’] == client_name:
print(“The client {} is in the client list”.format(client_name))
return True
print(‘The client: {} is not in client list’.format(client_name))
return False

if name == ‘main’:
_print_welcome()
command = input()
command = command.upper()

if command == "C": #CREAR
    client = _get_client()
    create_client(client)
    list_clients()
elif command == "L": # LISTAR
    list_clients()
elif command == "U": #UPDATE
    list_clients()
    updated_client_id = _get_client_field('id')
    update_client(int(updated_client_id))
    list_clients()
elif command == "D": # DELETE
    client_id = _get_client_field('id')
    delete_client(int(client_id))
    list_clients()
elif command == "S": # SEARCH
    list_clients()
    client_name = _get_client_field('name')
    search_client(client_name)
else: # OTHERWISE
    print("Invalid command.!")

from re import U
import sys


class Client():

    def __init__(self, client_name: str = None, client_company: str = None, client_email: str = None, client_position: str = None):
        self.name = client_name
        self.company = client_company
        self.email = client_email
        self.position = client_position

    def _set_name(self, client_name):
        client_name =_get_client_attribute('name',client_name)
        self.name=client_name

    def _set_company(self, client_company):
        client_company =_get_client_attribute('company',client_company)
        self.company = client_company

    def _set_email(self, client_email):
        client_email =_get_client_attribute('email',client_email)
        self.email = client_email

    def _set_position(self, client_position):
        client_position =_get_client_attribute('position',client_position)
        self.position = client_position


clients = []
clients.append(Client('Manuel','TecM','[email protected]','Mprofessor'))
clients.append(Client('Briones','TecB','[email protected]','Bprofessor'))

def create_client(client_name):
    global clients
    
    found,client_f,idx = search_client(client_name)
    if not found:
        new_client=Client()
        new_client._set_name(client_name)
        new_client._set_company(None)
        new_client._set_email(None)
        new_client._set_position(None)
        clients.append(new_client)
    else:
        _client_exists(client_f.name)

def list_clients(to_print: bool = True):
    global clients
    for idx, client in enumerate(clients):
        print(f'El cliente {idx} es {client.name}, trabaja en {client.company} como {client.position}')

def delete_client(client_name):
    global clients
    found,client_f,idx = search_client(client_name)
    if found:
        clients.pop(idx)
    else:
        _client_doesnt_exists(client_name)


def update_client(client_name, new_client_name,new_client_company,new_client_email,new_client_position):
    global clients
    found,client_f,idx = search_client(client_name)
    if found:
        if new_client_name != 'Nc':
            clients[idx]._set_name(new_client_name)
        if new_client_company != 'Nc':
            clients[idx]._set_company(new_client_company)
        if new_client_email != 'Nc':
            clients[idx]._set_email(new_client_email)
        if new_client_position != 'Nc':
            clients[idx]._set_position(new_client_position)
    else:
        _client_doesnt_exists(client_name)


def search_client(client_name):
    global clients
    found = False
    for idx,client in enumerate(clients):
        if client_name == client.name:
            found = True
            return found, client,idx
        else:
            continue
    return found, None,None

def _get_client_attribute(attribute, client_attribute: str = None):
    while not client_attribute:
        client_attribute = input(f'Client {attribute}: ').lower().title()
        if client_attribute == 'exit':
            client_attribute = None
            break
    if not client_attribute:
        sys.exit()

    return(client_attribute)


def _client_exists(client_name):
    return print(f'{client_name} is in client\'s list')

def _client_doesnt_exists(client_name):
    return print(f'{client_name} is not in client\'s list')


def _print_welcome():
    print('Welcome to Platzi Ventas')
    print('*'*50)
    print('What would you like to do today? ')
    print('[C]reate client ')
    print('[D]elete client')
    print('[L]ist client')
    print('[U]pdate client')
    print('[S]earch client')


def main():
    _print_welcome()
    command = input().lower()

    if command == 'l':
        pass
    else:
        client_name=_get_client_attribute('name')
        if command == 'c':
            create_client(client_name)
        elif command == 'd':
            delete_client(client_name)
        elif command == 'u':
            print('\'Nc\' for no change')
            new_client_name = _get_client_attribute('new name')
            new_client_company = _get_client_attribute('new company')
            new_client_email = _get_client_attribute('new email')
            new_client_position = _get_client_attribute('new position')
            update_client(client_name, new_client_name,new_client_company,new_client_email,new_client_position)
        elif command == 's':
            found = search_client(client_name)
            if isinstance(found,int):
                _client_exists(client_name)
            else:
                _client_doesnt_exists(client_name)
    list_clients()


    

if __name__ == '__main__':
    main()

Mi aporte para actualizar informacion ya sea name o company etc

mi aporte para eliminar

Mi aporte para buscar por nombre, company y email

Mi versión

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineering'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineering'
    }
]


def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print("Client alerady is in the client's list")


def list_clients():
    for idx, client in enumerate(clients):
        print("{uid} | {name} | {company} | {email} | {position}".format(uid=idx, name=client['name'],
                                                                        company=client['company'], email=client['email'],
                                                            position=client['position']))


def _get_client_idx(client_name):
    for idx, client_id in enumerate(clients):
        if client_id['name'] == client_name:
            return idx


def update_client(client_name):
    global clients

    if search_clients(client_name):
        print(f"The client {client_name} already exists")
        print("please insert the new data")
        update_client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
        index = _get_client_idx(client_name)
        clients[index] = update_client
    else:
        print("Client is not in clients list")


def delete_client(client_name):
    global clients

    if search_clients(client_name):
        clients.remove(clients[_get_client_idx(client_name)])
    else:
        print("Client is not in clients list")


def search_clients(client_name):
    for client in clients:
        if client['name'] != client_name:
            continue
        else:
            return True
    return False


def _add_comma():
    global clients

    clients += ','


def _print_welcome():
    print("WELCOME TO PLATZI VENTAS")
    print("*" * 50)
    print("What would you like to do today?")
    print("[C]reate client")
    print("[U]pdate client")
    print("[D]elete client")
    print("[S]earch client")


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}? '.format(field_name))

    return field.capitalize()


def _get_client_name():
    client_name = None
    while not client_name:
        client_name = input('What is the client name? ')

        if client_name.lower() == 'exit':
            client_name = None
            break

    if not client_name:
        sys.exit(1)

    return client_name.capitalize()


if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()
    if command == "C":
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
        create_client(client)
        list_clients()
    elif command == "D":
        client_name = _get_client_field('name')
        delete_client(client_name)
        list_clients()
    elif command == "U":
        client_name = _get_client_field('name')
        update_client(client_name)
        list_clients()
    elif command == "S":
        client_name = _get_client_field('name')
        found = search_clients(client_name)

        if found:
            print('The client is in the client\'s list')
        else:
            print("The client: {} is not in our client's list".format(client_name))

    else:
        print('Invalid command')

HICE EL RETO y logre modificar las 3 funciones yo solo… guao! por primera VEZ estoy pensando en python directamente, fluido! este curso me ha llevado a otro nivel! de verdad, que buena decision tome al comenzarlo

Aqui les dejo todo lo que lo que tengo escrito.

Los emails siempre se cargan en minúscula y el resto de los campos lo va a cargar en mayúscula pero los obtiene tanto en minúsculas como en mayúsculas

Se puede cargar updatear cualquier campo y cositas así.

Espero ayude

import sys


clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    },
    {
        'name': 'Martin',
        'company': 'Casa Piola',
        'email': '[email protected]',
        'position': 'Slave',
    },
    {
        'name': 'A',
        'company': 'A',
        'email': '[email protected]',
        'position': 'A',
    },
    {
        'name': 'Martin',
        'company': 'Avencis',
        'email': '[email protected]',
        'position': 'Coordinator',
    },
]


def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client is already in the client\'s list')


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'],
            ))

    
def update_client(client):
    global clients

    new_field = ""

    for index in range(len(clients)):
        if clients[index]['name'] == client['name'] and clients[index]['email'] == client['email']:
            print('What do you want to update ???? ')
            print('[N]ame')
            print('[C]ompany where you work')
            print('[E]mail')
            print('[P]osition')
            question = input()
            question = question.title()
            valid_choices = ['N', 'C', 'E', 'P']
            if question not in valid_choices:
                print('Next time choose one valid character "N, C, E, P"')
                update_client(client)
                break

            new_field = input('Write new field: ')
            new_field = new_field.title()            
            if question == 'N':
                clients[index]['name'] = new_field
                break
            elif question == 'C':
                clients[index]['company'] = new_field
                break
            elif question == 'E':
                new_field = new_field.lower()
                clients[index]['email'] = new_field
                break
            elif question == 'P':
                clients[index]['position'] = new_field
                break
    if new_field is not "":
        return
    else:
        print('\n Not user with the data input \n')


def delete_client(client):
    global clients

    for index in range(len(clients)):
        if clients[index]['name'] == client['name'] and clients[index]['company'] == client['company'] and clients[index]['email'] == client['email']:
            del clients[index]
            break

    else:
        print('Client is not in the List')

    
def search_client(client_name):
    global clients
    counter = 0
    for index in range(len(clients)):        
        if clients[index]['name'] == client_name:
            counter += 1
    
    if counter == 1:
        print('There is just one user with named {}. '.format(client_name))
    elif counter > 1:
        print('There are {} users named {}. '.format(counter, client_name))
    else:
        print('There is not user named {} in our records.'.format(client_name))

            # if counter == 0:
            #     print('No {} in our records'.format(client_name))
            #     break
            # else:
            #     print('There are {} account with this name'.format(counter))
            #     return True
            

def _get_client_field(field_name):
    field = None

    while not field:
        field = input('Whats is the client {} ?'.format(field_name))
        field = field.title()
        if field_name == 'email':
            field = field.lower()
        if field == 'Exit':
            field = None
            sys.exit()

    return field


def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('What is the client name? ')
        client_name = client_name.title()

    if client_name == 'exit':
        client_name = None
        sys.exit()

    return client_name


def _print_welcome():
    print('\n' + '-' * 42 + '\n')
    print('WELCOME to Sells for ALLs')
    print('\n' + '-' * 42 + '\n')
    print('What do you want to do?? ')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


if __name__ == '__main__':
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'D':
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
        }
        print(client)
        delete_client(client)
        list_clients()
    elif command == 'U':
        client = {
            'name': _get_client_field('name'),
            'email': _get_client_field('email'),
        }
        update_client(client)
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        print(client_name + ' estamos abajo')
        # search_client(client/_name)
        search_client(client_name)

        # if found:
        #     print('The client is in our client\'s list')
        # else:
        #     print('The client {} is NOT in our client\'s list'.format(client_name))
    else:
        print('Invalid input')

Reto: Depaso ahorramos algo de codigo

import sys

clients = [
    {
    'name':'Pablo',
    'company': 'google',
    'email': '[email protected]',
    'position': 'Software Engineer',
    },
    {
    'name':'Ricardo',
    'company': 'Facebook',
    'email': '[email protected]',
    'position': 'Data Enginner',
    }

      ]



def list_clients():
    global clients
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client['position'])
            )


def create_client(client):
    global clients      # con global podemos usar variables externas dentro de la funcion
    if client not in clients:
        clients.append(client)
    else:
        print('The client already is in the client\'s list')


def search_client(client_name):
    global clients
    valid = False
    for idx, client in enumerate(clients):
        if client_name in client.values():
            valid = True
            index = idx
            break

    return valid, index


def update_client(update_client, index):
    global clients
    clients[index] = update_client


def delete_client(index):
    global clients
    clients.pop(index)


def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print("*"*50)
    print('What do you like to do today')
    print('[C]reate Client')
    print('[L]ist Client')
    print('[U]pdate Client')
    print('[D]elete Client')
    print('[S]earch Client')

def _get_client_field(field_name):
    field = None
    while not field:
        field = input('What is the client {}?'.format(field_name))

    return field


def _get_client_field_all():
    client = {
                    'name': _get_client_field('name'),
                    'company': _get_client_field('company'),
                    'email': _get_client_field('email'),
                    'position': _get_client_field('position'),
                 }
    return client


def _get_client_name():
    client_name = None

    while not client_name:
        client_name= input('What is the client name? ')
        if client_name == 'exit':
            client_name = None
            break

    if not client_name:
        sys.exit()
    return client_name

if __name__ == '__main__':

    _print_welcome()
    command = input()
    command = command.upper()
    if command == 'C':
        client = _get_client_field_all()
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        is_valid, index = search_client(client_name)
        if is_valid:
            delete_client(index)
        else:
            print('The Client is not in Client\'s list')
        list_clients()
    elif command == 'U':
        client_name = _get_client_name()
        is_valid, index = search_client(client_name)
        if is_valid:
            updated_client = _get_client_field_all()
            update_client(updated_client,index)
        else:
            print(' The Client is not in Client\'s list')

        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)[0]
        if found:
            print('The client is in the client\'s list')
        else:
            print('The client {} is not in our client\'s list'.format(client_name))
    else:
        print('Invalid Command')

Mi solución, lo que hice fue validar primero si el cliente existía, tanto para poder crearlo, actualizar o eliminar. Perdón por el mal ingles.

<
clients = [
    {
        'name': 'David Fernando',
        'company': 'google',
        'email': '[email protected]',
        'position': 'engenieer'
    },

    {
        'name': 'David Josué',
        'company': 'amazon',
        'email': '[email protected]',
        'position': 'architect engenieer'
    }
]


def get_index_client(name):

    for index, clientupdate in enumerate(clients):
        if clientupdate ['name'] == name:
            return index


def validate_client(name):
    global clients
    tem= True
    for c in clients:
        if name == c['name']:
            
            tem=True 
            return tem
               
        else:
            tem=False

    return tem

def add_client(client):
    
        global clients
        clients.append(client)
        print("name added successfully")
        list_client()

      
def print_welcome():
    print("******WELCOME PLATZI VENTAS ***** ")
    print('-'*50)
    print('What would you like to do today ?')
    print('[C] Create client')
    print('[R] Read client')
    print('[U] Update client')
    print('[D] Delete client')
    print('[S] Search client')

def get_client_field(option):
    opt = True
    while opt:
        dato = input(f'What is the {option} ')
        
        if dato !=None:
            opt = False
   
    return dato
    
def question_of_name():
    name = input("What is the name of the client")
    return name

def list_client():
    global clients
    for index, cliente in enumerate(clients):
        
        print(f"{index} | {cliente['name']} | {cliente['company']} | {cliente['email']} | {cliente['position']}")

def update_client(client):
    global clients
    index = get_index_client(client['name'])
    clients[index]=client
    list_client()

def delete_client(index):
    global clients
    
    clients.pop(index)
    list_client()
    

def search_client(name):
    
    global clients
    for index, cliente in enumerate(clients):
        if name == cliente['name']:
            print(f"{index} | {cliente['name']} | {cliente['company']} | {cliente['email']} | {cliente['position']}")    
        

if __name__ == "__main__":

    
    print_welcome()

    option = input(" ").upper()
    if option == 'C':

        name= get_client_field('name')
        
        if not validate_client(name):
            client={
            'name':name,
            'company':get_client_field('company'),
            'email':get_client_field('email'),
            'position':get_client_field('position')
            }
            add_client(client)
        else:
            print('the name of client already exists')
    elif option == 'R':
        list_client()
    elif option == 'U':

        name = get_client_field('name')
        if validate_client(name):
            client={
                'name':name,
                'company':get_client_field('company'),
                'email':get_client_field('email'),
                'position':get_client_field('position')
            }
            update_client(client)

        else:
            print("the client does not exist")
    elif option == 'D':
        name = get_client_field('name')
        if validate_client(name):
            delete_client(get_index_client(name))

        else:
            print("the client does not exist")
    elif option == 'S':
        name = get_client_field('name')
        if validate_client(name):
            search_client(name)
        else:
            print("the client does not exist")
            

> 

También se puede listar de la siguiente forma, ya no tendríamos que utilizar enumerate.

def list_client():
    for i in range(len(clients)):
        print('{}: {}'.format(i,clients[i]['name']))

<
import sys
from ast import Delete
from http import client
from turtle import position


clients = [
    {
        'name':'Pablo',
        'company': 'Google',
        'email' : '[email protected]',
        'position' : 'Software engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email' : '[email protected]',
        'position' : 'Data engineer',

    }


]


def create_client(client):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        _client_was_found()


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company}  {email} | {position}'.format(
            uid = idx,
            name = client['name'],
            company = client['company'],
            email = client['email'],
            position = client['position'],
        ))


def update_client (client_name, updated_client_name):
    global clients

    if client_name in clients:
        index = clients.index(client_name)
        clients[index] = updated_client_name
    else:
        _client_not_found()


def delete_client(client_name):
    global clients
    for client in clients:
        if client_name == client['name']:
           command = input('Estas seguro de borrar este cliente? Y/N ')
           command = command.upper()
           if command == 'Y':
                clients.remove(client)
           else:
               print('Se cancelo el proceso de borrar un usuario')
               sys.exit()
        else:
            _client_not_found()


def search_client(client_name):
    for client in clients:
        if client['name'] != client_name:
            continue
        else:
            return True


def _print_welcome():
    print('BIENVENIDOS A PLATZI VENTAS')
    print('*'*50)
    print('Que quieres hacer hoy?')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name):
    field = None

    while not field:
        field = input('Cual es el {}?  '.format(field_name))
    return field

def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('Cual es el nombre del cliente? ')

        if client_name == 'exit':
            break
        if not client_name:
            sys.exit()

    return client_name


def _get_index(client_name):
    global clients

    for idx, client in enumerate(clients):
        print(idx)
        if client['name'] == client_name:
            return idx

def _client_not_found():
    return print('El cliente no esta registrado en la lista')


def _client_was_found():
    print('El cliente ya esta registrado en la lista')


if __name__ == '__main__':
    _print_welcome()
    command = input("Escribe un comando: ")
    command = command.upper()
    if command == 'C':
        client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('comapany'),
        'email' : _get_client_field('email'),
        'position' : _get_client_field('position'),
        }

        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif command == 'U':
        client_name = _get_client_name()
        updated_client_name = input('Inglrese la actualizacion en el nombre: ')
        update_client(client_name, updated_client_name)
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)
        if found:
            print('Se encontro el cliente en la lista')
        else:
            _client_not_found()
    else:
        print('Comando invalido')

> 

Mi solución del curso hasta ahora, sin usar POO, tuplas, sets, y decoradores.

import sys
clients: list = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software engineer',
    },
    {
        'name': 'Mauricio',
        'company': 'Reserve',
        'email': '[email protected]',
        'position': 'Backend developer',
    }
]


def _get_client_data():
    client: dict = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position')
    }

    return client


def _create_client():
    request: bool = True
    while request:
        client = _get_client_data()

        if client not in clients:
            clients.append(client)
        else:
            print(f'Client "{client["name"]}" already is in the client\'s list')
        
        user_chose = input("Do you want to continue? Y/N: ")
        user_chose = user_chose.upper()
        
        if user_chose == "Y" or user_chose == "YES":
            request = True
        elif user_chose == "N" or user_chose == "NO":
            request = False
            print("-"*50)
            print("\nOk! Request Completed successfully")
        else:
            request = False
            print("Stopping...")


def _delete_client(client_id):
    is_valid, index = client_id

    if is_valid:
        client = clients[index]
        while True:
            confirm = input(f"Are you secure to remove {client['name']} from client\'s data?: ").upper()
            if confirm == "YES":
                print(f'{index}: {clients[index]} was delete')

                del(clients[index])
                list_clients()
                break
            elif confirm == "NO":
                print("Stopping...")
                break
            else:
                print('Print Yes or No to continue')
    else:
        print('Client isn\'t in the client list.')


def _get_client_id() -> list[bool, int]:
    """
    Get a user integer id
    """
    is_logic: bool = False

    while not is_logic:
        try:
            # If the user sent a not valid value, use exception for error's prevention
            client_id: int = int(input('- Write client id: '))
            is_valid = True

            if clients[client_id] not in clients:
                print('Sorry, that index is out of range or was not found')
                is_valid = False

            return [is_valid, client_id]

        except IndexError:
            print('Please write a valid index')

        except ValueError:
            print('Please write a number.\n')


def _get_client_field(data):
    """
    Return a username
    """
    client_info = None

    while not client_info:
        print(f'{"-" * 20} # insert "exit" to break')
        client_info = str(input(f'Client\'s {data}: '))

        if client_info.lower() == 'exit':
            client_info = None
            break

    if not client_info:
        sys.exit()

    return client_info


def _update_client(client_id: list):
    validator = client_id[0]
    index = client_id[1]

    if validator:
        new_client: dict = _get_client_data()

        clients[index] = new_client
    else:
        print('Client is not in the client list.')


def _read_clients():
    print('[s] to show this list')
    print('[f] to find a client')
    chose: str = input('Please, chose one: ').lower()

    if chose == 's':
        list_clients()
    elif chose == 'f':
        target, index = _get_client_id()

        if target:
            client = clients[index]
            print(f'The client {client["name"]} was found!')
        else:
            print(f'The client was not found')
    else:
        print('Ups! We don\'t have that option.\nPlease send feedback at @maucoder on twitter to more updates!')


def _print_welcome():
    print('Welcome to CMT POS')
    print('-'*50)
    print('What would you like to do today')
    print('Create clients - Write "C"')
    print('Show clients - Write "R"')
    print('Update clients - Write "U"')
    print('Delete clients - Write "D"')


def list_clients():
    for idx, client in enumerate(clients):
        print(f'{idx}: {client["name"]} | {client["company"]} | {client["email"]} | {client["position"]}')


def run():
    global clients
    _print_welcome()

    command = input("\nYour chose: ").lower()
    
    if command == 'c':
        _create_client()
        list_clients()
    elif command == 'r':
        _read_clients()
    elif command == 'd':
        client = _get_client_id()

        _delete_client(client)
    elif command == 'u':
        client = _get_client_id()
        _update_client(client)

        list_clients()
    else:
        print('Invalid command, please select an available option')


if __name__ == '__main__':
    run()

hola!
Esta es mi solución validando si el usuario existe con la llave 'name' antes de realizar alguna acción como pedir datos del cliente

import sys


clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer'
    }
    
]


def create_client(client):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print('\ Client already is in the client\'s list')
    
    
def list_clients():
    global clients
    for idx, client in enumerate(clients):
        print(f"\n{idx} || {client['name']} || {client['company']} || {client['email']} || {client['position']}")


def update_client(index: int, updated_client):
    global clients
    
    clients[index] = updated_client
    print(f"\n Updated client")
    return


def delete_cliente(index: int):
    global clients
    
    del(clients[index])
    print(f"\n Deleted client")
    return


def search_client(client_name):
    global clients
    
    for client in clients:
        index = clients.index(client)
        if client_name == client['name']:
            return True, index
        
    print(f"\n The client {client_name} is not in our client\'s list")
    return False, False


def _print_welcome():
    print('\n     WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('What would you like to do today')
    print('[C]reate client')
    print('[L]ist client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


def _get_client_field(command, field_name):
    field = None
    if command == 'C':
        while not field:
            field = input(f" What is the client {field_name}: ").capitalize()
    elif command == 'U':
        while not field:
            field = input(f" What is the updated client {field_name}: ").capitalize()
    elif command == 'D':
        while not field:
            field = input(f" What is the {field_name} of the client to delete: ").capitalize()
       
    return field
    

if __name__ == '__main__':    
    _print_welcome()
    command = input('\n → ').upper()
    
    if command == 'C':
        client = {'name': _get_client_field(command,'name'),
                  'company': _get_client_field(command,'company'),
                  'email': _get_client_field(command,'email'),
                  'position': _get_client_field(command,'position')          
        }
        
        create_client(client)
        list_clients()
      
    elif command == 'L':
          list_clients()
        
    elif command == 'D':
        client_name = _get_client_field(command, 'name')
        found = search_client(client_name)
        if found[0]: 
            delete_cliente(int(found[1])) #found[1]= index si el cliente existe en clients
        list_clients()
        
    elif command == 'U':
        client_name = _get_client_field('C', 'name')
        found = search_client(client_name)
        if found[0]:
            updated_client = {'name': _get_client_field(command,'name'),
                  'company': _get_client_field(command,'company'),
                  'email': _get_client_field(command,'email'),
                  'position': _get_client_field(command,'position')          
            }
            update_client(int(found[1]), updated_client)
        list_clients()        
        
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)
        if found[0]:
            print('\n The client is in the client\'s list')
            
    else:
        print('\nInvalid Command')     

Les comparto mi versión del código.

import sys


clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    }
]


def create_client(client):
    global clients
    clients.append(client)


def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'],
        ))


def update_client(client_name, new_client):
    global clients

    for idx,client in enumerate(clients):
        if client['name'] == client_name:
            clients[idx] = new_client


def delete_client(client_name):
    global clients

    for idx,client in enumerate(clients):
        if client['name'] == client_name:
            clients.pop(idx)
            break


def search_client(client_name):
    found = False

    for client in clients:
        if client['name'] == client_name:
            found = True
            print("Client name {} was found".format(client_name))
            break

    if not found:
        print("Client name {} was not found".format(client_name))

    return found


def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input("What is the client name? ")
        if client_name == 'exit':
            sys.exit()

    return client_name


def _create_client_dict():
    client_fields = ['name', 'company', 'email', 'position']
    client = {}

    for field in client_fields:
        while not client.get(field):
            client[field] = input("What is the new {}? ".format(field))
            if client[field] == 'exit':
                client = {}
                sys.exit()

    return client


def _print_welcome():
    print("\nWELCOME TO PLATZI VENTAS")
    print("*" * 50)
    print("What would you like to do today?")
    print("[C]reate client")
    print("[D]elete client")
    print("[U]pdate client")
    print("[S]earch client")
    print("[E]xit\n")


if __name__ == '__main__':

    while True:
        _print_welcome()

        command = input(": ")
        command = command.upper()

        if command == "C":
            client = _create_client_dict()
            found = search_client(client['name'])
            if not found:
                create_client(client)
            else:
                print("Client is already in list!")
            list_clients()
        elif command == "D":
            client_name = _get_client_name()
            found = search_client(client_name)
            if found:
                delete_client(client_name)
            list_clients()
        elif command == 'U':
            client_name = _get_client_name()
            found = search_client(client_name)
            if found:
                new_client = _create_client_dict()
                update_client(client_name, new_client)
            list_clients()
        elif command == 'S':
            client_name = _get_client_name()
            search_client(client_name)
            list_clients()
        elif command == 'E':
            print("Good bye!")
            break
        else:
            print("Invalid command!")```

Utilicé el nombre del cliente como referencia en las búsquedas. En un ambiente productivo creería que es mejor utilizar el email, el cual debiera ser el identificador único de cada usuario.

Modifiqué unas cosas para que imprima de una vez si el usuario no está en la lista

import sys


clients = [
    {
        "name": "Pablo",
        "company": "google",
        "email": "[email protected]",
        "position" :"Software engineer",
    },
    {
        "name": "Ricardo",
        "company": "facebook",
        "email": "[email protected]",
        "position" :"Data engineer",
    }
    
]

def create_client(client):
    global clients

    if client not in clients:
        
        clients.append(client)        

    else:
        print('Client already is in the client\'s list')

def list_clients():
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(uid =idx, 
                                                                    name = client['name'],
                                                                    company = client['company'],
                                                                    email = client['email'],
                                                                    position = client['position']))
                                                

def update_client(client_id, updated_client):
    global clients


    clients[client_id] = updated_client 
    
             
def delete_client(client_name):
    global clients

    if client_name in clients:
        clients.remove(client_name)
    else:
        print('Client is not in clients list')


def search_client(client_name):

    for client in clients:
        if client != client_name:
            continue
        else:
            return True     


def _print_welcome():
    print('WELCOME TO PLATZY VENTAS')
    print('*'*50)
    print('What would you like to do today?')
    print('[L]ist clients')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}: '.format(field_name))
    
    return field


def _get_client_name():
    client_name = None

    while not client_name:
        client_name =  input('What is the client name?')

        if client_name == 'exit':
            client_name = None
            break

    if not client_name:
            sys.exit()   


    return client_name  

def _get_client_from_user():
    client = {
        'name': _get_client_field('name'),
        'company': _get_client_field('company'),
        'email': _get_client_field('email'),
        'position': _get_client_field('position'),
    }

    return client  


if __name__ =='__main__':
    _print_welcome()

    command = input('Ingresa una opcion: ')
    command = command.upper()

    if command == 'C':
        client ={
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
            
            }
       
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()

    elif command == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    
    
    elif command == 'U':
        client_id = int(_get_client_field('id'))
        

        if client_id <=len(clients):        
            updated_client = _get_client_from_user()

            update_client(client_id, updated_client)
            list_clients()

        else:
            print('Client is not in client\'s list')        
        

    elif command =='S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found:
            print('The client is in the client\' list')

        else:
            print('The client: {} is not in our client\'s list'.format(client_name))


    
    
    
    
    
    else:
        print('Invalid command')

Let me show my poor code🤪😵

import sys
import os

client_list = [
    {
        'Name': 'Kathy',
        'Last Name': 'Ulloa Garcia',
        'Position': 'Agent',
        'Company': 'CCD
    },
    {
        'Name': 'Brayan Alexander',
        'Last Name': 'Vasquez',
        'Position': 'Student',
        'Company': 'Who knows....'
    },
]

def check_if_in_list(name): # ALREADY RUNNING UNDER DICTIONARY
    global client_list

    for dictionary in client_list:
        if name not in dictionary['Name']:
            return True
        else:
            return False


def _optimization(client):
    _temp_dicitonary = {
        'Name': '{}'.format(client),
        'Last Name': '{}'.format(__get_client_field('Last Name')),
        'Position': '{}'.format(__get_client_field('Position')),
        'Company': '{}'.format(__get_client_field('Company'))
    }
    return _temp_dicitonary


def _add_client(client_name): # ALREADY RUNNING UNDER DICTIONARY
    global client_list

    if check_if_in_list(client_name):
        client_list.append(_optimization(client_name))
    else:
        print("Already in the list.")


def _search_client(client_name): # ALREADY RUNNING UNDER DICTIONARY
    global client_list
 
    for _dictionary in client_list:
        
        if client_name not in _dictionary['Name']:
            continue
        else:
            return True


def _update_client(client_name, updated_name): # ALREADY RUNNING UNDER DICTIONARY
    global client_list
    element_updated = False

    for _dictionary in client_list:
        if client_name in _dictionary['Name']:
            
            _dictionary.update(_optimization(updated_name))
            element_updated = True

    if element_updated:
        print(f'Element {client_name}, sucessfully removed')
    else:
        print(f'Element {client_name}, not updated/found')


def _delete_client(client_name): # ALREADY RUNNING UNDER DICTIONARY
    global client_list
    _index = 0
    element_removed = None

    for _dictionary in client_list:
        if _dictionary['Name'] == client_name:
            element_removed = client_list.pop(_index)
        _index += 1

    if element_removed != None:
        print(f'Element {client_name}, sucessfully removed')
    else:
        print(f'Element {client_name}, not removed/found')


def view_list(): # ALREADY RUNNING UNDER DICTIONARY
    global client_list

    for field in client_list:
        print(f"\nNombre: {field['Name']} \nApellido: {field['Last Name']} \nPosicion: {field['Position']} \nCompany: {field['Company']}")
        

def _welcome_window():
    os.system('cls')
    print(8 * "*" + "  WELCOME TO THIS CLIENT SERVICE  " + 8 * "*")
    print("MAIN MENU:\n")

    print("[A]dd new Client")
    print("[U]pdate  Client")
    print("[D]elete  Client")
    print("[S]earch  Client")
    print("[E]xit")

    what_to_do = ""
    while what_to_do == "":
        what_to_do = input("\nwhat would you like to do: ")

    return what_to_do
 

def __get_client_field(working_with):

    field = ""
    while field == "":
        field = input(f"What's Client's {working_with}: ")

    return field


def _control(decition):
    decition = decition.upper()

    if decition == "A":

        _add_client(__get_client_field('Name'))
        
    
    elif decition == "U":

        _update_client(__get_client_field('Name'), __get_client_field('Name'))
        

    elif decition == "D":
        
        _delete_client(__get_client_field('Name'))
        

    elif decition == "S":

        if _search_client(__get_client_field('Name')):
            print(f"\nName was found")
            view_list()
            input('\nPress Any key to Continue....')
        else:
            print("Name wasnt found")
    
    elif decition == "E":
        sys.exit()
    else:
        print("Invalid Command")

if __name__ == "__main__":
    new_command = None
    while new_command != 'E':
        new_command = _welcome_window()
        _control(new_command)

Probe el codigo del profesor en la funcion DELETE pero al eliminar el indice cero si volvia a listar los clientes me mostraba 2 indices ceros y no liminaba el cliente diciendo que no estaba en la lista de clientes.
Le di vueltas pero la verdad no se por que ese “bug” jejeje.

Aqui les dejo mi trozo de codigo de la funcion DELETE_CLIENT, el resto del condigo es casi igual

#DELETE
def delete_client(client_id):
  global clients

  if client_id == 0:
    clients.pop(0)
  elif len(clients) - 1 == client_id:
    clients.remove(clients[client_id])
  else:
    print('Client is not in clients list')

def _get_index_dict(seq, key):
return next((index for (index, d) in enumerate(seq) if d[“name”] == key), None)

El reto:

import sys
import os

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software engineer'
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data engineer'
    }
]


def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    global clients

    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']))



def update_client(client_id, updated_client):
    global clients
    if client_id <= len(clients) - 1:
        clients[client_id] = updated_client
    else:
        _message_not_client()
            



def delete_client(client_id):
    global clients

    for idx, client in enumerate(clients):
        if idx == client_id:
            del clients[idx]
            break
        


def search_client(client_name):
    global clients


    for client in clients:
        if client != client_name:
            continue
        else:
            return True


def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('What would you like to do day?')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


def _get_client_field(field_name):
    field = None
    while not field:
        field = input('What is the client {}? '.format(field_name))
    return field


def _get_client_name():
    client_name = None

    while not client_name:
        client_name = input('What is the client name? ')

        if client_name == 'exit':
            client_name = None
            break

    if not client_name:
            sys.exit()

    return client_name


def _message_not_client():
    print('Client is not in client\'s list')


def _get_client():
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),

        } 
        return client


if __name__ == '__main__':
    os.system('clear')
    _print_welcome()

    command = input()
    command = command.upper()

    if command == 'C':
        client = _get_client()
        create_client(client)
        list_clients()
    elif command == 'L':
        list_clients()
    elif command == 'D':
        client_id = int(_get_client_field('uid'))
        delete_client(client_id)
        list_clients()
    elif command == 'U':
        client_id = int(_get_client_field('uid'))
        updated_client = _get_client()
        update_client(client_id, updated_client)
        list_clients()
    elif command == 'S':
        client_name = _get_client_name()
        found = search_client(client_name)

        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in our client\'s list'.format(client_name))
    else:
        print('Invalid command')


    

en esta version puedes ENCONTRAR AL CLIENTE SOLO CON EL NOMBRE para cada caso y despues agregar los campos que tengas que agregar o modificar. asi mismo el codigo esta modularizado y creo que se puede editar para buscar otro parametro como “id”. me esta pareciendo genial este curso como repaso de todo lo visto hasta ahora en la carrera de backend con Python.

import sys
from typing import Collection

clients = [
    {
        'name': 'Pablo',
        'company': 'google',
        'email': '[email protected]',
        'position': 'software engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'facebook',
        'email': '[email protected]',
        'position': 'data engineer',
    }
]

def create_client(client):
    global clients
    
    if client not in clients:
        clients.append(client)
    else:
        print(f'The {client.get("name")}is already in the client\'s list')


def list_clients():
    for idx, client in enumerate(clients):
        print(f'{idx}: {client.get("name"),client.get("company"),client.get("email"), client.get("position")}')
        
        # MANERA ALTERNA DE HACERLO:
        # print('{uid} | {name} | {company} | {email} | {position}'
        # .format(uid=idx, 
        #     name=client['name'],
        #     company=client['company'],
        #     email=client['email'],
        #     position=client['position']))


def search_client(client_name):  # funcion para buscar y confirmar la existencia de un cliente.
    global clients

    index = [0]
    found = False
    for idx,client in enumerate(clients):  # enumerate devuelve los valores  del "indice idx" y en "clients" que hay en ese indice correspondiente y los guarda en "client".
        for name in client.values():  # idx es el indice de los diccionarios con los datos de los clientes en "clients" y al llamarlo aqui podemos llamar a los valores que contiene con el metodo ".values()", por que hace referencia automatica a esta lista anidada.
            if client_name == name:
                found = True
                index = int(idx)
                return found, index
            
    return found, index # regresa dos valores despues de generar todas las iteraciones y no encontrar nada


def update_client(client_name):
    global clients

    client_found, index = search_client(client_name)  # se hace swaping para retomar los dos valores que se generan en la funcion: un booleano y un indice numerico
    if client_found:
        update_client_fields = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }  
        clients[index] = update_client_fields
    else:
        _not_client_found(client_name)


def delete_client(client_name):
    global clients

    client_found, index = search_client(client_name)
    if client_found:
        clients.pop(index) # elimina todo el diccionario con los datos del cliente en el index señalado
    else:
        _not_client_found(client_name)


def _print_welcome():
    print('\nWELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('what would you like to do today? ')
    print('[C]reate client')
    print('[L]ist clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name):
    field = None
    while not field:
        field = input(f'What is the client {field_name}?')
    
    return field
    

def _get_client_name(action):
    client_name = None

    while not client_name:
        client_name = input((f'What is the client name to {action}?').strip() )

        if client_name == 'exit':
            client_name = None
            break
    if not client_name:
        sys.exit()

    return client_name


def _not_client_found(client_name):
    print(f'{client_name} is not in client list')


if __name__ == '__main__':
    _print_welcome()
    
    command = input()
    command = command.upper()

    if command == 'C':
        client = {
            'name': _get_client_field('name'),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
        create_client(client)
        list_clients()
    elif command == 'L': #LISTO*******
        list_clients()
    elif command == 'U': #LISTO*******
        action = 'Update'
        client_name = _get_client_name(action)
        update_client(client_name)
        list_clients()
    elif command == 'D': #LISTO*******
        action = 'Delete'
        client_name = _get_client_name(action)
        delete_client(client_name)
        list_clients()
    elif command == 'S': #LISTO*******
        action = 'Search'
        client_name = _get_client_name(action)
        client_found, index = search_client(client_name)  # esta variable toma ambos valores que la funcion devuelve

        if client_found: # tres opciones de imprimir los resultados
            print(f'The {client_name} is in the client\'s list')
            # print(f'{index}: {clients[index].get("name")}:{clients[index].get("company")}:{clients[index].get("email")}:{clients[index].get("position")}')
            # print(f'{index}: {clients[index].values()}')
            print(f'{index}: {clients[index]}')
        else:
            _not_client_found(client_name)
    else:
        print('Invalid command')

Esta fue mi forma de plantear Update
lo que hice fue crear un diccionario interno y ver que valores queria que actualizara y cuales no

def update_client(update_client_name, client_name):
    global clients
    for client in clients:
        if updated_client_name in client['name']:
            print('If you don\'t want to update a die, just put \None')
            client_list = {'name' : client_name, 'company' : _get_client_field('company'), 'email' :_get_client_field('email'), 'position': _get_client_field('position')}
            for key , value in client_list.items():
                if value == 'None':
                    client_list[key] = client[key]
            client.update({'name' : client_list['name'], 'company' :client_list['company'], 'email': client_list['email'], 'position': client_list['position']})
        else:
            print('Client is not in clients list')

Hola amigos,
Comparto mi implementación del la función update_client()
.

Reto: realizado con Python 3.10

from typing import List, Dict

import sys
import re

rgx_input = re.compile(r'\w+:.*')

clients: List[Dict[str, str]] = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Sofware Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    },
]

def create_client(client: Dict[str, str]):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print("Client is already in the client's list.")
        

def read_clients():
    for index, client in enumerate(clients, start = 1):
        print(
            """
              uid: {iud},
              name: {name},
              company: {company},
              email: {email},
              position: {position}
            """.format(
                  iud = index,
                  name = client['name'], 
                  company = client['company'],
                  email = client['email'],
                  position = client['position']
                )
        )
        
        
def update_client(key: str, old_value: str, new_value: str):
    global clients

    client_filteted: List[Dict[str, str]] = _filter_list(clients, key, old_value)
    
    for client in client_filteted:
        client.update({key: new_value})


def delete_client(key: str, value: str):
    global clients

    client_filtered: List[Dict[str, str]] = [
        client for client in clients if not (client.get(key) == value)
    ]
    clients = client_filtered
        
        
def search_client(key: str, value: str) -> bool:
    global clients
    
    client: List[Dict[str, str]] = _filter_list(clients, key, value)
    return True if client else False


def _print_welcome():
    print('Welcome to Platzi ventas.')
    print('*' * 50)
    print('What would you like to do today?')
    print('[C]reate a client')
    print('[R]ead the clients')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch a client')
    print('*' * 50)
    

def _get_client_field(field_name: str) -> str:
    field: str = None
    
    while not field:
        field = input('What is the client {}? '.format(field_name))
        
    return field

  
def _get_list() -> List[str]:
    key_value: str = None
    
    while not key_value:
        key_value = input('Enter the key & value separated by ":" ')
        
        if key_value == 'exit':
            key_value = None
            break
        
    if not key_value:
        sys.exit()

    assert type(re.search(rgx_input, key_value).string) == str, f'Input the key & value separated by ":" '
    return key_value.split(':')


def _filter_list(
            list_dict: List[Dict[str, str]],
            key: str,
            value: str
    ) -> List[Dict[str, str]]:

    filtered: List[Dict[str, str]] = list(filter(
            lambda arr: arr.get(key) == value, list_dict
        )
    )
    return filtered


def main():
    _print_welcome()
    
    selection: str = input()
    selection = selection.upper()
    
    match selection:
        case 'C':
            
            client: Dict[str, str] = {
                'name': _get_client_field('name'),
                'company': _get_client_field('company'),
                'email': _get_client_field('email'),
                'position': _get_client_field('position')
            }
            create_client(client)
            read_clients()
        
        case 'R':

            read_clients()
            
        case 'U':
            
            arr: List[str] = _get_list()
            assert len(arr) == 3, f'Input the key: old value: new value correctly.'
            update_client(arr[0], arr[1], arr[2])
            read_clients()
            
        case 'D':
            
            arr: List[str] = _get_list()
            assert len(arr) == 2, f'Input the key & value separated by ":" '
            delete_client(arr[0], arr[1])
            read_clients()
            
        case 'S':
            
            arr: List[str] = _get_list()
            assert len(arr) == 2, f'Input the key & value separated by ":" '
            print(f'Is {arr[1]} in the client list? {search_client(arr[0], arr[1])}')
        
        case _:
            print('Invalid input.')
            sys.exit()


if __name__ == '__main__':
    main()

Mi aporte

import sys
clients = [
    {
        'name':'pablo',
        'company':'google',
        'email':'[email protected]',
        'position':'software enginner'
    },
    {
        'name':'ricardo',
        'company':'facebook',
        'email':'[email protected]',
        'position':'data enginner'
    }
]


def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    global clients
    for idx, client in enumerate(clients):
        print("{uid} | {name} | {company} | {email} | {position}".format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'],
        ))

def update_client(client_name, updated_client):
    global clients

    client_found:bool = False
    
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            client_found=True
            clients.pop(idx)
            clients.insert(idx,updated_client)
            break
        
    if not client_found:
        print('Client is not in clients list')

def delete_client(client_name):
    global clients

    client_found:bool = False
    
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            client_found=True
            clients.pop(idx)
            break

    if not client_found:
        print('Client is not in clients list')

def search_client(client_name):
    global clients

    client_found:bool = False
    
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            client_found=True
            break

    return client_found


def _print_welcome():
    print('Bienvenidos a platzi ventas')
    print('*'*50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[L]ist clients')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name):
    field = None

    while not field:
        field=input('What is the client {}? '.format(field_name))

    return field

def _get_client_name(action):
    client_name=None

    while not client_name:
        client_name=input('What is the client name to {}? '.format(action))

        if client_name=='exit':
            client_name=None
            break

    if not client_name:
        sys.exit()
    
    return client_name


if __name__=='__main__':
    _print_welcome()

    command = input()
    command=command.upper()

    if command=='C':
        client ={
            'name':_get_client_field('name'),
            'company':_get_client_field('company'),
            'email':_get_client_field('email'),
            'position':_get_client_field('position')
        } 
        create_client(client=client)
        list_clients()
    elif command=='D':
        client_name=_get_client_name('delete')
        delete_client(client_name)
        list_clients()
    elif command=='L':
        list_clients()
    elif command=='U':
        client_name = _get_client_name('update')
        updated_client = {
            'name':_get_client_field('name'),
            'company':_get_client_field('company'),
            'email':_get_client_field('email'),
            'position':_get_client_field('position')
        } 
        update_client(client_name=client_name, updated_client=updated_client)
        list_clients()
    elif command=='S':
        client_name = _get_client_name('Search')
        found=search_client(client_name)
        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in out client\'s list'.format(client_name))
        list_clients()
    else:
        print('Invalid command')

    

Yo lo resolví de esta manera.

import sys
clients = [
    {
        'name':'pablo',
        'company':'google',
        'email':'[email protected]',
        'position':'software enginner'
    },
    {
        'name':'ricardo',
        'company':'facebook',
        'email':'[email protected]',
        'position':'data enginner'
    }
]


def create_client(client):
    global clients

    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the client\'s list')


def list_clients():
    global clients
    for idx, client in enumerate(clients):
        print("{uid} | {name} | {company} | {email} | {position}".format(
            uid=idx,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position'],
        ))

def update_client(client_name, updated_client):
    global clients

    client_found:bool = False
    
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            client_found=True
            clients.pop(idx)
            clients.insert(idx,updated_client)
            break
        
    if not client_found:
        print('Client is not in clients list')

def delete_client(client_name):
    global clients

    client_found:bool = False
    
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            client_found=True
            clients.pop(idx)
            break

    if not client_found:
        print('Client is not in clients list')

def search_client(client_name):
    global clients

    client_found:bool = False
    
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            client_found=True
            break

    return client_found


def _print_welcome():
    print('Bienvenidos a platzi ventas')
    print('*'*50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[L]ist clients')
    print('[D]elete client')
    print('[S]earch client')

def _get_client_field(field_name):
    field = None

    while not field:
        field=input('What is the client {}? '.format(field_name))

    return field

def _get_client_name(action):
    client_name=None

    while not client_name:
        client_name=input('What is the client name to {}? '.format(action))

        if client_name=='exit':
            client_name=None
            break

    if not client_name:
        sys.exit()
    
    return client_name


if __name__=='__main__':
    _print_welcome()

    command = input()
    command=command.upper()

    if command=='C':
        client ={
            'name':_get_client_field('name'),
            'company':_get_client_field('company'),
            'email':_get_client_field('email'),
            'position':_get_client_field('position')
        } 
        create_client(client=client)
        list_clients()
    elif command=='D':
        client_name=_get_client_name('delete')
        delete_client(client_name)
        list_clients()
    elif command=='L':
        list_clients()
    elif command=='U':
        client_name = _get_client_name('update')
        updated_client = {
            'name':_get_client_field('name'),
            'company':_get_client_field('company'),
            'email':_get_client_field('email'),
            'position':_get_client_field('position')
        } 
        update_client(client_name=client_name, updated_client=updated_client)
        list_clients()
    elif command=='S':
        client_name = _get_client_name('Search')
        found=search_client(client_name)
        if found:
            print('The client is in the client\'s list')
        else:
            print('The client: {} is not in out client\'s list'.format(client_name))
        list_clients()
    else:
        print('Invalid command')

    

Esta es mi versión.
Ya ingresé manejo de errores por si se ingresa un número mayor al de la lista y también por si se ingresa una letra en lugar de un número para el índice
Cualquier retroalimentación es bienvenida

import sys


clients: list = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Software engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data engineer',
    }
]


def create_client(client: dict) -> None:
    global clients
    if client not in clients:
        clients.append(client)

    else:
        print('Client is already registered')


def list_clients() -> None:
    for idx, client in enumerate(clients):
        name = client['name']
        company = client['company']
        email = client['email']
        position = client['position']
        print(f'{idx}{" "*(4-len(str(idx)))}|{name}{" "*(10-len(name))}|{company}{" "*(20-len(company))}|{email}{" "*(25-len(email))}|{position}')


def update_client(client_id: int, updated_client: dict) -> None:
    global clients

    for idx, _ in enumerate(clients):
        if idx == client_id:
            clients[idx] = updated_client
    


def delete_client(client_id: int) -> None:
    global clients
    if client_id < len(clients):
        for idx, _ in enumerate(clients):
            if idx == client_id:
                del clients[idx]
    else:
        raise IndexError('The index introduced, is incorrect')


def search_client(client_id: int) -> bool:
    global clients
    
    found = False
    for idx, _ in enumerate(clients):
        if idx == client_id:
            found = True
            break
    
    return found


def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*'*50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[D]elete client')
    print('[U]pdate client')
    print('[S]earch client')
    print('[L]ist clients')


def _get_client_field(field_name: str) -> str:
    field = None
    while not field:
        field = input(f"What's the client {field_name}\n->")
    return field
    

# def _get_client_name() -> str:
#     client_name = None

#     while not client_name:
#         client_name = input("What's the client name?\n-> ")
        
#         if client_name == 'exit':
#             client_name = None
#             break

#     if not client_name:
#         sys.exit()

#     return client_name


def ask_client_data()-> dict:
    client = {
            'name':_get_client_field('name').capitalize(),
            'company': _get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
        }
    return client


if __name__ == '__main__':
    _print_welcome()
    command = input('->').upper()
    print("*"*30)
    list_clients()

    if command == 'C':
        client = ask_client_data()
        create_client(client) 

    elif command == 'D':
        client_id = None
        while True:
            try:
                client_id = int(_get_client_field('id'))
                delete_client(client_id)
                break
            except ValueError:
                print('Type a valid id')
            except IndexError as ie:
                print(ie)
        

    elif command == 'U':
        client_id = None
        while True:
            try:
                client_id = int(_get_client_field('id'))
                assert client_id < len(clients), 'The indx introduced is incorrect'
                updated_client = ask_client_data()
                update_client(client_id, updated_client)
                break
            except ValueError:
                print('Type a valid id')
            except AssertionError as ae:
                print(ae)


    elif command == 'S':
        client_name = _get_client_field('name')
        if search_client(client_name.capitalize()):
            print("The client is in the Client's List")
        else:
            print("The client: {} is not the Client's List".format(client_name))

    elif command == 'L':
        pass 
    else:
        print('Comando inválido')
    

    print(f'\nLista Actualizada:\n{"*"*30}')
    list_clients()

import sys
from typing import KeysView

clients=[
    {
        'name':'pablo',
        'company':'Google',
        'email':'[email protected]',
        'position':'software engineer',
    },
    {
         'name':'ricardo',
         'company':'facebook',
         'email':'[email protected]',
         'position':'Date engineer',  
    },

]


def create_client(client):
    global clients
    if client not in clients:
        clients.append(client)
    else:
        print('Client already is in the cliente\'s list')


def list_clients():
    #print('{}   {}   {}      {}           {} '.format('id', 'name','company','email','position'))
    for idx,client in enumerate(clients):
        
        print('{}  {}   {}    {}   {}'.format(idx,client['name'],client['company'],client['email'],client['position']))


            

def update_clients(client_name, client):
    global clients
    
    for indice in clients:
        if client_name == indice['name']:
            indice.update(client)
            break
    

def delete_clients(client_name):
    global clients
    i=0
    for indice in clients:
        if client_name in indice['name']:
            i+=1
            clients.remove(indice)
    if i==0:
        print('Client is not in clients list')


def search_client(client_name):
    for indice in clients:
        if indice['name'] !=client_name:
            continue
        else:
            return True


def _get_client_field(field_name):
    field=None

    while not field:
        field=input('What is the client {}: '.format(field_name))
    
    return field


def _get_client_from_user():
    client={
        'name':_get_client_field('name'),
        'company':_get_client_field('company'),
        'email':_get_client_field('email'),
        'position':_get_client_field('position'),
    }
    return client

def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('-'*35)
    print('what would you like to do today?')
    print('[C]reate client')
    print('[L]ist client')
    print('[D]elete client')
    print('[U]pdate client')
    print('[S]earch client')


if __name__=='__main__':
    _print_welcome()
    
    command=input()
    command=command.upper()

    if command=='C':
        client=_get_client_from_user()
        create_client(client)
        list_clients()
    elif command=='L':
        list_clients()
    elif command == 'D':
        client_name=_get_client_field('name')
        delete_clients(client_name)
        list_clients()
    elif command == 'U':
        client_name=_get_client_field('name')
        found=search_client(client_name)
        if found:
            client=_get_client_from_user()
            update_clients(client_name,client)
        else:
            print('The client {} is not in our client\'s list'.format(client_name))
        list_clients()    
    elif command == 'S':
        client_name=_get_client_field('name')
        found= search_client(client_name)
        if found:
            print('The client is in the client\'s  list ')
        else:
            print('The client {} is not in our client\'s list'.format(client_name))
    else:
        print('Invalid command')
    

No llama al indice, sino al nombre para el update

import sys

clients = [
    {
        'name': 'Pablo',
        'company': 'Google',
        'email': '[email protected]',
        'position': 'Sofware Engineer',
    },
    {
        'name': 'Ricardo',
        'company': 'Facebook',
        'email': '[email protected]',
        'position': 'Data Engineer',
    },
    {
        'name': 'Junior',
        'company': 'Bitel',
        'email': '[email protected]',
        'position': 'Electrónico',
    }
]
def _get_client_field(field_name):
    field = None
    while not field:
        field = input('What is the client {}?'.format(field_name))
    return field
def _get_client_name():
    client_name = None
    ## 19. While loops
    while not client_name:
        client_name = input('What is the client name? ').strip()
        if client_name == 'exit':
            client_name = None
            break
    if not client_name:
        sys.exit()
    return client_name        

def create_client(client):
	global clients  
	if client not in clients:
		clients.append(client)
	else:
		print('Client already exists')

def update_client(client_name):
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            clients.pop(idx)
            clients.append(input_client())
        else:
            print('Client is not clients list')            
        
def delete_client(client_name):
    global clients
    for idx, client in enumerate(clients):
        if client_name == client['name']:
            clients.pop(idx)
        else:
            print('Client isD not clients list')  

def search_client(client_name):
    ## 18. For loops
    for client in clients:
        if client != client_name:
            continue
        else:
            return True
def input_client():
    client={
            'name': _get_client_field('name'),
            'company':_get_client_field('company'),
            'email': _get_client_field('email'),
            'position': _get_client_field('position'),
            }
    return client
    
        
def list_clients(): 
    for idx, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position}'.format(
            uid =idx, 
            name =client['name'],
            company = client['company'],
            email =client['email'],
            position =client['position']))
def _add_coma():  
	global clients
	clients +=", "

def _print_welcome():
    print ('Welcome to Monares POS')
    print ('*' * 52)
    print ('what would you like to do today?')
    print ('[C]reate client')
    print ('[L]ist client')
    print ('[S]earch client')
    print ('[D]elete client')
    print ('[U]pdate client')

if __name__ == '__main__':
    _print_welcome()
    command = input().lower()
    if command == 'c':
        create_client(input_client())
        list_clients()
    elif command == 'l':
            list_clients()
    elif command == 'u':
        client_name = input('What is the client name? ').strip()
        update_client(client_name)
        list_clients()
    elif command == 'd':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif command == 's':
        client_name = _get_client_name()
        found = search_client(client_name)
        if found:
            print('The client is in the client\'s list')
        else:
            print(f'The client {client_name} i not in our client\'s list')
    else:
        print('Invalid command')

input()

Reto cumplido

Funciones auxiliares:

def input_create(field):

    field = input('What is the client ' + field + '? ').capitalize()

    return field


def get_id(client_name):

    for idx, client in enumerate(clients):

        if client['name'] == client_name:

            return idx