B谩sicos del Lenguaje

1

Gu铆a de instalaci贸n y conceptos b谩sicos

2

Archivos y slides del curso pr谩ctico de Python

3

IMPORTANTE: Instalando Ubuntu Bash en Windows para facilitarte el seguimiento del curso desde Windows.

4

驴Qu茅 es la programaci贸n?

5

驴Por qu茅 programar con Python?

6

Operadores matem谩ticos

7

Variables y expresiones

8

Presentaci贸n del proyecto

9

Funciones

10

Usando funciones en nuestro proyecto

11

Operadores l贸gicos

12

Estructuras condicionales

Uso de strings y ciclos

13

Strings en Python

14

Operaciones con Strings en Python

15

Operaciones con strings y el comando Update

16

Operaciones con strings y el comando Delete

17

Operaciones con strings: Slices en python

18

For loops

19

While loops

20

Iterators and generators

Estructuras de Datos

21

Uso de listas

22

Operaciones con listas

23

Agregando listas a nuestro proyecto

24

Diccionarios

25

Agregando diccionarios a nuestro proyecto

26

Tuplas y conjuntos

27

Tuplas y conjuntos en c贸digo

28

Introducci贸n al m贸dulo collections

29

Python comprehensions

30

B煤squedas binarias

31

Continuando con las B煤squedas Binarias

32

Manipulaci贸n de archivos en Python 3

Uso de objetos y m贸dulos

33

Decoradores

34

Decoradores en Python

35

驴Qu茅 es la programaci贸n orientada a objetos?

36

Programaci贸n orientada a objetos en Python

37

Scopes and namespaces

38

Introducci贸n a Click

39

Definici贸n a la API p煤blica

40

Clients

41

Servicios: L贸gica de negocio de nuestra aplicaci贸n

42

Interface de create: Comunicaci贸n entre servicios y el cliente

43

Actualizaci贸n de cliente

44

Interface de actualizaci贸n

45

Manejo de errores y jerarqu铆a de errores en Python

46

Context managers

Python en el mundo real

47

Aplicaciones de Python en el mundo real

Conclusiones finales

48

Python 2 vs 3 (Conclusiones)

Clases bonus

49

Entorno Virtual en Python y su importancia: Python en el mundo real

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Operaciones con strings y el comando Delete

16/49
Recursos

En esta clase seguiremos construyendo nuestro proyecto PlatziVentas, agregaremos el comando delete para poder borrar nuestros clientes y pondremos en pr谩ctica lo aprendido en clases anteriores sobre Strings.

Aportes 88

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

CRUD

(C)reate
(R)ead or retreive
(U)pdate
(D)elete

Es un modelo muy utilizado por cient铆ficos de computadores. Se usa mucho en aplicaciones web, para construir modelos usables.

def _client_not_found():
	return print('Client is not in clients list')

Un crud es algo b谩sico, sin embargo por experiencia he visto que muchos desarrolladores no pasan esta prueba t茅cnica (Hacer un crud a partir de un CSV), pero eso si se llenan la boca auto nombrandose Senior 馃槙

C贸digo actualizado y comentadocon las sugerencias de los dem谩s compa帽eros.
Espero les sirva 馃槑馃憤

#proyecto_final
clients = 'Rogelio, Paco, Sebastian, Adrian' #creamos el string con los nombres de los clientes

def _print_welcome(): #funcion para dar el mensaje de bienvenida
	print ('Welcome to Monares POS')
	print ('what would you like to do today?')
	print ('*' * 52)  #imprimimos el caracter "*" 52 veces
	#Mostramos el menu al usuario
	print ('[C]reate client')
	print ('[R]ead client\'s list ')
	print ('[U]pdate client')
	print ('[D]elete client')


def verify_client(client_name):
	"""
	Esta funcion sirve para verificar si un cliente se encuentra en el string o no.
	Recibe un parametro, el nombre del cliente y devuelve un valor positivo si el nombre
	se encuentra en el string y viceversa
	"""
	global clients
	if client_name in clients:
		return True
	else:
		return False


def _client_not_found_tollgate():
	"""
	Esta funcion sirve para mostrar un mensaje preestablecido si un cliente no se encuentra 
	en el string de los clientes
	"""
	print ("Client is not in client\'s list")


def create_client(client_name):
	"""
	Esta funci贸n sirve para agregar un cliente al string de la lista
	"""
	global clients  #Utilizamos global para definir que la variable es la global, es decir la que definimos con pablo y ricardo
	if (verify_client(client_name)): #Ejecutamos la funcion verify client, si la cadena del nombre del cliente est谩 en el string etonces...
		print('Client already exists') #Mostramos un mensaje al usuario
	else:
		_add_coma() #Si no, ejecutamos la funcion _add_coma para agregar una coma y un espacio al 煤ltimo nombre
		clients += client_name #adicionamos el nuevo string pero con la funcion capitalize para poner el primer caract茅r en mayuscula y seguir con el formato


def read_client_list(): 
	"""
	funci贸n que imprime la lista de clientes
	"""
	global clients
	print (clients) #imprimimos el string clientes, es decir la lista de clientes


def update_client(client_name):
	"""
	Funci贸n que sirve para actualizar el nombre de un cliente, 
	recibe un parametro que es el string del nombre del cliente a editar
	"""
	global clients #Utilizamos global para definir que la variable es la globarl, es decir la que definimos con pablo y ricardo
	if (verify_client(client_name)): #Si el cliente se encuentra registrado entonces...
		updated_client_name = input('What is the updated client name?').capitalize() #Pedimos al usuario que ingrese el nuevo nombre de cliente
		clients = clients.replace(client_name, updated_client_name) #Ejecutamos la funcion replace, la cual recibe dos parametros, el string a reemplazar
		#y el string con el cual se remplazara al anterior
	else:
		_client_not_found_tollgate() #sino, ejecutamos la funcion _client_not_found_tollgate() para mostrar el mensaje que no se ha encontrado el cliente (string)
		

def delete_client(client_name):
	"""
	Funci贸n para borrar el cliente (Remplazar por una cadena vac铆a)
	"""
	global clients
	if (verify_client(client_name)): #Si el cliente est谩 registrado, entonces...
		clients = clients.replace(client_name + ', ', '') #Remplazamos el nombre concatenado con una , y un espacio y lo remplazamos por una cadena vac铆a
	else:
		_client_not_found_tollgate() #sino, ejecutamos la funcion _client_not_found_tollgate() para mostrar el mensaje que no se ha encontrado el cliente (string)


def _add_coma():  #el nombre de la funci贸n comienza con un gui贸n bajo para establecer que ser谩 una funcion privada
	"""
	Funci贸n que sirve para agregar una coma y un espacio para separar los substrings
	"""
	global clients
	clients +=", " #se agrega una coma y un espacio al string para separar los nuevos valores


def _get_client_name():
	"""
	Funci贸n que sierve para obtener el nombre del cliente con el formato capitalizado
	"""
	return input('What is the client name?').capitalize()  #guardamos en la variable client_name el valor de los caracteres que ingresa el usuario hasta recibir un enter


if __name__ == '__main__': #funcion main
	_print_welcome() #ejecutamos la funcion que da el mensaje de bienvenida
	command = input().lower() #guardamos el valor del dato ingresado en la variable command pero lo convertimos a miunsculas para realizar la accion si presiona "C" o "c"
	if command == 'c': #si el comando es igual al caracter "c" procedemos a realizar los pasos de create/crear
		client_name = _get_client_name() #Ejecutamos la funci贸n para obtener el nombre del cliente
		create_client(client_name) #Ejecutamos la funcion crear cliente y enviamos como parametro el valor de la variable que almacena lo que digit贸 el usuario
		read_client_list() #Ejecutamos la funcion listar clientes 
	elif command == 'r': #si el comando es igual al caracter "r" procedemos a realizar los pasos de read/leer
		read_client_list()  #Ejecutamos la funcion listar clientes 
	elif command == 'u': #si el comando es igual al caracter "u", procedemos a realizar los pasos de update/actualizar
		client_name = _get_client_name() #Ejecutamos la funci贸n para obtener el nombre del cliente
		update_client(client_name)
		read_client_list() #Ejecutamos la funcion listar clientes 
	elif command == 'd': #si el dato ignresado por el usuario es "d" procedemos a realizar los pasos de delete/eliminar
		client_name = _get_client_name() #Ejecutamos la funci贸n para obtener el nombre del cliente
		delete_client(client_name)
		read_client_list() #Ejecutamos la funcion listar clientes 
	else:
		print('ERROR: Invalid command') #Si el usuario no digita alguna de nuestras opciones entonces mostramos un mensaje de error
input() #Escribimos un input para que el programa haga una pausa y no cierre la ventana hasta recibir un enter

Creo que mientras mas avanzo mas me gusta esto, comparto mi codigo con funcion de accion y validar si existe cliente.



clients= 'pablo,ricardo,'


def create_client(client_name):
    global clients

    if client_name not in clients:
        clients+=client_name
        _add_comma()
    else:
        print('Client already is in the clien\'s list ')

def list_clients():
    global clients
    print(clients)


def update_client(client_name,updated_client_name):
    global clients

    if client_name in clients:
        clients=clients.replace(client_name+',',updated_client_name+',')
    else:
        print('Client is not in clients list')

def delete_client(client_name):
    global clients

    _exist_client(client_name)
    Exist_client= _exist_client(client_name)
    print(Exist_client)
    if Exist_client==True :
        clients=clients.replace(client_name+',','')


def _exist_client(client_name):
    global clients

    if client_name not in clients:
        print('Client is not in clients list')
        return False
    elif client_name is None or client_name=='':
        print('Client is Empty')
        return False
    else:
        return True



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


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

#def _get_client_name():
#    return input('what is the client name?')

#def _get_updated_client_name():
#    return input('what is the updated client name?')

def _get_input_action(value):
    action=''

    if value == 1:
        action=input('what is the client name?')
        _exist_client(action)

    elif value == 2:
        action=input('what is the updated client name?')
        _exist_client(action)
    else:
        action=print('Invalid value for input action')
    return action



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

    if command == 'C':
       client_name =_get_input_action(1)
       create_client(client_name)
       list_clients()
    elif command == 'D':
       list_clients()
       client_name = _get_input_action(1)
       delete_client(client_name)
       list_clients()
    elif command == 'U':
       list_clients()
       client_name = _get_input_action(1)#_get_client_name()
       updated_client_name = _get_input_action(2)#_get_updated_client_name()
       update_client(client_name,updated_client_name)
       list_clients()
    else:
        print('Invalid command')

Saludos, les comparto mi c贸digo. Trabaje con Arrays en lugar de una variable tipo str.



clients = ['Ramiro', 'Daniel', 'Jose']


def create_client(client_name):
    global clients
    if client_exists(client_name):
        _message_system(1)
    else:
        # clients += client_name
        # _add_coma()
        clients.append(client_name)
        

def delete_client(client_name):
    global clients
    if client_exists(client_name):
        # clients = clients.replace(client_name, '')
        clients.remove(client_name)
    else:
        _message_system(2)


def update_client(client_name, new_client_name):
    global clients
    if client_exists(client_name):
        # clients = clients.replace(client_name, new_client_name)
        pos = clients.index(client_name) 
        clients.pop(pos)
        clients.insert(pos, new_client_name)
    else:
        _message_system(2)


def client_exists(client_name):
    global clients
    # if client_name+','in clients:
    if client_name in clients:
        return True


def _add_coma():
    global clients
    clients += ', '


def list_client():
    global clients
    # print(clients)
    for client in clients:
        print(client)


def _print_menu():
    print(('*' * 50) + '\nWELCOME TO PLATZI VENTAS\n' + ('*' * 50))
    print('What do you like to do today?')
    print('[C]reate client.')
    print('[U]pdate client.')
    print('[D]elete client.')
    print('[L]ist clients')
    print('[E]xit')


def _message_system(num_message):
    if num_message == 0:
        return print('Thanks for everything.\nHave a nice day.')
    elif num_message == 1:
        return print('Client already is in the client\'s list!.')
    elif  num_message == 2:
        return print('Client isn\'t in the client\'s list!.')
    elif  num_message == 3:
        return print('Invalid command.')


def _get_cliente_name():
    return input('What is the client name?.\n').capitalize()


def crud_scheme():
    while True:
        command = input('\nOption:\t').upper()
        
        if command == 'C':
            client_name = _get_cliente_name()
            create_client(client_name)

        elif command == 'D':
            client_name = _get_cliente_name()
            delete_client(client_name)

        elif command == 'U':
            client_name = _get_cliente_name()
            if client_exists(client_name):
                update_client_name = input('Please, Write the new client name:\n').capitalize()
                update_client(client_name, update_client_name)
            else:
                _message_system(2)

        elif command == 'L':
            list_client()

        elif command == 'E':
            _message_system(0)
            break

        else:
            _message_system(3)


if __name__ == '__main__':
    _print_menu()
    
    crud_scheme()


        
    ```

esta es la manera que construi mi funcion.

Para no repetir el mensaje decid铆 crear una funci贸n auxiliar en la cual dependiendo un c贸digo, me imprime el mensaje que necesito. Aqu铆 mismo puedo ir agregando mensajes gen茅ricos que se ir谩n utilizando en la aplicaci贸n.

No seria mas eficiente poner remove en vez de dejar un string vacio ? .
Saludos muy buen curso !!!

Aqu铆 les dejo mi c贸digo, pueden aprender de el, intenten leerlo y mejoren su capacidad lectora como programadores 鉂わ笍

global_clients = 'Iv谩n, Paolo, Platzi'

def create_client(client_name):
    global global_clients

    if client_name not in global_clients and len(global_clients) > 1:
# La condicional "and len(global_clients) > 1" es porque cuando borras todos los clientes
# e intentas crear uno nuevo la lista queda as铆 ", nombre" y eso se ve mal
        global_clients += ', ' + client_name
    elif client_name not in global_clients:
        global_clients += client_name
# En este elif colocamos el cliente sin coma, el elif solo se comple si no hay ningun cliente en global_clients
    else:
        print('repeated client')


def update_client(client_name, updated_name):
    global global_clients

    if client_name in global_clients:
        global_clients = global_clients.replace(client_name, updated_name)
    else:
        print('nonexistent client')


def delete_client(client_name):
    global global_clients

    if client_name in global_clients and client_name != '':
# la condicional "and client_name != ''" es para que si no colocas nada, no se borren las comas, pruebenlo para ver que pasa
        global_clients = global_clients.replace(client_name + ', ', '') # Estas lineas de codigo son
        global_clients = global_clients.replace(', ' + client_name, '') # para que se vea bien esteticamente
        global_clients = global_clients.replace(client_name, '')        # y que no haya comas flotando o dobles comas
    else:
        print('nonexistent client')



def read_clients():
    print(global_clients)


def _menu():
    print('          WELCOME')
    print('-' * 40)       # El * 40 repetira el simbolo "-" 40 veces
    print('What would you like to do today?')

# CRUD    C = create | R = read | U = update | D = delete

    print('1 = Create a client')
    print('2 = Read clients')
    print('3 = Update client')
    print('4 = Delete a client')
    print('0 = Exit')


if __name__ == '__main__':

    _command = '1'

    while _command != '0':           # Este while es para que a menos que el comando sea 0, siga saliendo el menu infinitamente
        _menu()

        _command = input()

        if _command == '1':
            create_client(input('What is the name of the client? '))
        elif _command == '2':
            read_clients()
        elif _command == '3':
            update_client(input('What is the name of the client? '), input('What is the updated client name? '))
        elif _command == '4':
            delete_client(input('What is the name of the client? '))

Si alguien as铆 como yo se qued贸 con la duda de por que usar if name == 鈥main鈥: , en el siguiente link viene una muy buena explicaci贸n:

https://es.stackoverflow.com/questions/32165/qu茅-es-if-name-main

Que emocionante! Me muero por saber como manejar clases y guardar datos en el disco duro 馃槃

CRUD: Create, Replace, Update, Delete.

Supongo, no?

def _client_exists(client_name):
    global clients
    if client_name+',' in clients:
        return True
    else:
        print('Client is not in client list.')

Lo acomode de la siguiente manera:

def update_client(client_name, update_client_name):
    global clients

    if _find_client(client_name):
        clients = clients.replace(client_name, update_client_name)
    

def delete_client(client_name):
    global clients

    if _find_client(client_name):
        clients = clients.replace(client_name + ',', '')


def _find_client(client_name):
    global clients

    if client_name in clients:
       return True
    else:
        print('Client is not in clients list')
        return False

De todo esto me queda una inquietud con la variable 鈥渃lients鈥, porque esta se declara global dentro de las funciones, y no por fuera de una sola vez

<code>

clients = 'pablo, ricardo,'


def create_client(client_name):
    global clients

    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        print('client already is in the client\'s list')


def list_clients():
    global clients

    print(clients)


def update_client(client_name, updated_client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',', updated_client_name + ',')
    else:
        print(_get_not_in_list())

def delet_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        print(_get_not_in_list())


def _add_comma():
    global clients

    clients += ','

def _print_welcome():
    print('welocome to platzi ventas')
    print('*' * 50)
    print('what would you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elate client')

def _get_client_name():
    return input('What is the client name?')
def _get_not_in_list():
    return input('client is nos in client list')

if __name__ == '__main__':
    _print_welcome()


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

    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        delet_client(client_name)
        list_clients()
    elif command == 'U':
        client_name = _get_client_name()
        updated_client_name = input('whats the o隆updated client name?')
        update_client(client_name, updated_client_name)
        list_clients
    else:
        print('Invalid command')

Patr贸n Com煤n (CRUD):
-Crear cliente
-Mostrar clientes
-Hacer update de clientes
-Borrar clientes,

*Es un patr贸n que nos vamos a encontrar por todos lados:Aplicaciones web que tengan(Apis), aplicaciones de escritorio(Gmail,Bloc de notas), Cualquier cosa que represente la programaci贸n, que requiera guardar, modificar, etc 鈥淰AMOS A NECESITAR ESTE PATR脫N鈥

yo use una lista, me parece mejor y mas ordenado


clients = ["pablo", "ricardo", ]


def add_client(client_name):
    global clients

    if client_name not in clients:
        clients.append(client_name)
        print("")
        print("Client Created".center(50, "*"))

    else:
        print("The client {} was already created".format(client_name).center(50))


def list_clients():
    global clients

    print(clients)


def _update_client(client_name):
    global clients

    if client_name in clients:
        update_name = str(input("What is the new client name? "))

        clients.remove(client_name)
        clients.append(update_name)
        print("")
        print("Update Client Name".center(50, "*"))

    else:
        print("The client {} does not exist".format(client_name).center(50))


def delete_client(client_name):
    global clients

    if client_name in clients:
        clients.remove(client_name)
        print("")
        print("Client Removed".center(50, "*"))

    else:
        print("The client {} is not in clients list".format(client_name).center(50))


def _get_client_name():
    return input("What is the client name? ")


def run():
    while True:

        command = str(input("""
            What would you like to do today?

            [C]reate client
            [U]pdate client
            [D]elete client
            [S]how clients
                [E]xit
        : """))

        command = command.upper()

        if command == "C":
            print("Create client".center(50, "="))
            print("")

            client_name = _get_client_name()
            add_client(client_name)

            print("")
            list_clients()

        elif command == "U":
            print("Update client".center(50, "="))
            print("")

            client_name = _get_client_name()
            _update_client(client_name)

            print("")
            list_clients()

        elif command == "D":
            print("Delete client".center(50, "="))
            print("")

            client_name = _get_client_name()
            delete_client(client_name)

            print("")
            list_clients()

        elif command == "S":
            print("Show clients".center(50, "="))
            print("")
            list_clients()

        elif command == "E":
            print("GOOD BYE".center(50, "="))
            break

        else:
            print("Command invalid")


if __name__ == "__main__":
    print("WELCOME TO PLATZI VENTAS".center(50, "="))
    run()

Buena clase, esto se va poniendo m谩s y m谩s interesante.
Tambi茅n es una buena idea utilizar un array/lista y ocupar .remove() para borrar el nombre del cliente, se me hizo m谩s sencillo de esa manera.

Hola, ac谩 pude simplicar el texto de 鈥淐lient is not in the List鈥. Aunque yo lo puse como 鈥淭he client is not registered鈥. Les dejo el c贸digo

He venido batallando para entender esta clase, apenas vi que hay una clase anterior para aprentder Python porque alguien lo coment贸. Entend铆 que, aunuque todo el tiempo estamos en modo consola, a veces estamos en el editor Vim, a veces en Python y a veces directo en la consola de ubuntu. Tuve que entender que hab铆a un programa llamado Vim que es el que edita el texto del programa en el que estamos trabajando y que tiene sus propios comandos para guardar lo que vamos haciendo.
Tal vez si pusieran como requisito conocimientos previos, o unos minutos para explicar c贸mo hace para guardar, para abrir, para regresar a editar鈥



M谩s que remplazar lo que hice fue eliminar aqu铆 el ejemplo:

# -*- codign: utf-8 -*-

# Variables & Const
global clients
clients = ['Miguel', 'David']

def run():
    """Start the software"""
    show_title()
    read_element()


def show_title():
    """Show custom title of 'Platzi Seller'"""
    title =  ('鈻堚枅鈻堚枅鈻堚枅鈺 鈻堚枅鈺      鈻堚枅鈻堚枅鈻堚晽 鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈺椻枅鈻堚枅鈻堚枅鈻堚枅鈺椻枅鈻堚晽    鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈺     鈻堚枅鈺     鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈻堚枅鈻堚枅鈺')
    complement = title
    title += ('\n鈻堚枅鈺斺晲鈺愨枅鈻堚晽鈻堚枅鈺     鈻堚枅鈺斺晲鈺愨枅鈻堚晽鈺氣晲鈺愨枅鈻堚晹鈺愨晲鈺濃暁鈺愨晲鈻堚枅鈻堚晹鈺濃枅鈻堚晳    鈻堚枅鈺斺晲鈺愨晲鈺愨暆鈻堚枅鈺斺晲鈺愨晲鈺愨暆鈻堚枅鈺     鈻堚枅鈺     鈻堚枅鈺斺晲鈺愨晲鈺愨暆鈻堚枅鈺斺晲鈺愨枅鈻堚晽')
    title += ('\n鈻堚枅鈻堚枅鈻堚枅鈺斺暆鈻堚枅鈺     鈻堚枅鈻堚枅鈻堚枅鈻堚晳   鈻堚枅鈺     鈻堚枅鈻堚晹鈺 鈻堚枅鈺    鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈻堚枅鈻堚晽  鈻堚枅鈺     鈻堚枅鈺     鈻堚枅鈻堚枅鈻堚晽  鈻堚枅鈻堚枅鈻堚枅鈺斺暆')
    title += ('\n鈻堚枅鈺斺晲鈺愨晲鈺 鈻堚枅鈺     鈻堚枅鈺斺晲鈺愨枅鈻堚晳   鈻堚枅鈺    鈻堚枅鈻堚晹鈺  鈻堚枅鈺    鈺氣晲鈺愨晲鈺愨枅鈻堚晳鈻堚枅鈺斺晲鈺愨暆  鈻堚枅鈺     鈻堚枅鈺     鈻堚枅鈺斺晲鈺愨暆  鈻堚枅鈺斺晲鈺愨枅鈻堚晽')
    title += ('\n鈻堚枅鈺     鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈺  鈻堚枅鈺   鈻堚枅鈺   鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈺    鈻堚枅鈻堚枅鈻堚枅鈻堚晳鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈻堚枅鈻堚枅鈻堚晽鈻堚枅鈺  鈻堚枅鈺')
    title += ('\n鈺氣晲鈺     鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺  鈺氣晲鈺   鈺氣晲鈺   鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺    鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺愨晲鈺愨晲鈺愨暆鈺氣晲鈺  鈺氣晲鈺')
    # Add Styles
    break_line = ('-' * len(complement) + "\n") * 2
    title = "{}\n{}\n{}\n".format(break_line, title, break_line)
    print(title)
    show_menu()
    

def show_menu():
    """Show the menu of 'Platzi Seller'"""
    options = [
        'List Client',
        'Create Client',
        'Update Client',
        'Delete Client',
        'Exit'
    ]
    count = 0
    print("Write a number of the next options:")
    for element in options:
        print("{}. {}".format(count, element))
        if count <= len(options): 
            count+= 1


def read_element():
    """Execute and make the process of the actions specifics"""
    option = 0
    while option != 4:
        input_data = input('\nOption: ')
        if input_data:
            option = int(input_data)
            response = action(option)
        else:
            response = 'No action allowed'
        print(response)


def action(option):
    """Select and Action"""
    response = "Any Action valid"
    if option == 0: # List
        response = show_all_clients()
    elif option == 1: # Create Client
        response = create_client()
    elif option == 2: # Update Client
        response = update_client()
    elif option == 3: # Delete Client
        response = delete_client()
    elif option == 4: # Exit
        response = 'Good Bye!'
    
    return response


def show_all_clients():
    """Print all Clients"""
    return ("This is your list:\n{}".format(clients))
    

def __show_all_clients_index():
    response = 'This is your list:\n'
    for client in enumerate(clients):
        response += "{}, ".format(client)
    print(response)


def create_client():
    """Create a Client"""
    name = input("Write a name of the client: ")
    if name:
        clients.append(name)
        return show_all_clients()
    else:
        return "The client name is empty"
        

def update_client():
    """Update a Client"""
    response = 'Any Change'
    __show_all_clients_index()
    index = input('\nWrite the index of the client: ')
    if index:
        index = int(index)
        if index >= 0 and index <= len(clients):
            name = input("Write a name of the client: ")
            if name:
                clients[index] = name
                response = "Client #{} is updated\n\n{}".format(index, show_all_clients())
    return response


def delete_client():
    """Delete a Client"""
    response = 'Any Change'
    __show_all_clients_index()
    index = input('\nWrite the index of the client: ')
    if index:
        index = int(index)
        if index >= 0 and index <= len(clients):
            del clients[index]
            response = "Client #{} is deleted\n\n{}".format(index, show_all_clients())
    return response


if __name__ == '__main__':
    run()```
Hice un poco diferente el c贸digo con una lista de clientes. ![](https://static.platzi.com/media/user_upload/image-076e55f4-5a3f-48b6-b642-0011491a42b5.jpg)
Les comparto mi c贸digo, le agregue un ciclo while para que despu茅s de cada operaci贸n vuelva a parecer el menu. ```js #El proyecto que se va a realizar, es un CRUD. #Tiene una 谩rea de l贸gica, 谩rea de persistencia y un 谩rea en la cu谩l interactuamos con el usuario, #esto lo haremos por medio de la l铆nea de comandos. def update_client(arr): client_to_change = input("Which is the name of the client tou would like to change? ").capitalize() if client_to_change in arr: client_index = arr.index(client_to_change) arr.pop(client_index) client_updated = input("What is the new name of the client? ").capitalize() arr.insert(client_index, client_updated) print(arr) print() def creat_cliente(arr): cliente_name = input("What is the client name? ").capitalize() if cliente_name not in arr: arr.append(cliente_name) print(arr) print() else: print("The client is already in the list") def delete_client(arr): cliente_name = input("What is the client name of the cliente you want to delete? ").capitalize() if cliente_name in arr: arr.remove(cliente_name) print(arr) print() else: print("The client is not in the list") def welcome_message(): print("WELCOME TO PLATZI VENTAS") print("*"*50) print("Press [S] to start.") def menu(): print("What would you like to do today?") print("[C]reate Client") print("[U]pdate Client") print("[D]elete Client") print("[E]xit") def run(): clients = ["Joselito"] menu_activo = 0 welcome_message() user_cmd = input().capitalize() if user_cmd == "S": menu_activo = 1 while menu_activo: menu() user = input().capitalize() if user == "C": creat_cliente(clients) elif user == "U": update_client(clients) elif user == "D": delete_client(clients) elif user == "E": menu_activo = 0 else: menu_activo = 0 if __name__ == '__main__': run() ```#El proyecto que se va a realizar, es un CRUD. #Tiene una 谩rea de l贸gica, 谩rea de persistencia y un 谩rea en la cu谩l interactuamos con el usuario, #esto lo haremos por medio de la l铆nea de comandos. *def* update\_client(*arr*):聽 聽 client\_to\_change = input("Which is the name of the client tou would like to change? ").capitalize()聽 聽 if client\_to\_change in *arr*:聽 聽 聽 聽 client\_index = *arr*.index(client\_to\_change)聽 聽 聽 聽 *arr*.pop(client\_index)聽 聽 聽 聽 client\_updated = input("What is the new name of the client? ").capitalize()聽 聽 聽 聽 *arr*.insert(client\_index, client\_updated)聽 聽 聽 聽 print(*arr*)聽 聽 聽 聽 print() *def* creat\_cliente(*arr*):聽 聽 cliente\_name = input("What is the client name? ").capitalize()聽 聽 if cliente\_name not in *arr*:聽 聽 聽 聽 *arr*.append(cliente\_name)聽 聽 聽 聽 print(*arr*)聽 聽 聽 聽 print()聽 聽 else:聽 聽 聽 聽 print("The client is already in the list") 聽 聽 *def* delete\_client(*arr*):聽 聽 cliente\_name = input("What is the client name of the cliente you want to delete? ").capitalize()聽 聽 if cliente\_name in *arr*:聽 聽 聽 聽 *arr*.remove(cliente\_name)聽 聽 聽 聽 print(*arr*)聽 聽 聽 聽 print()聽 聽 else:聽 聽 聽 聽 print("The client is not in the list") *def* welcome\_message():聽 聽 print("WELCOME TO PLATZI VENTAS")聽 聽 print("\*"\*50)聽 聽 print("Press \[S] to start.")聽 聽 *def* menu():聽 聽 print("What would you like to do today?")聽 聽 print("\[C]reate Client")聽 聽 print("\[U]pdate Client")聽 聽 print("\[D]elete Client")聽 聽 print("\[E]xit")聽 聽 *def* run():聽 聽 clients = \["Joselito"]聽 聽 menu\_activo = 0聽 聽 welcome\_message()聽 聽 user\_cmd = input().capitalize()聽 聽 聽 聽 if user\_cmd == "S":聽 聽 聽 聽 menu\_activo = 1 聽 聽 聽 聽 while menu\_activo:聽 聽 聽 聽 menu()聽 聽 聽 聽 user = input().capitalize()聽 聽 聽 聽 if user == "C":聽 聽 聽 聽 聽 聽 creat\_cliente(clients)聽 聽 聽 聽 elif user == "U":聽 聽 聽 聽 聽 聽 update\_client(clients)聽 聽 聽 聽 elif user == "D":聽 聽 聽 聽 聽 聽 delete\_client(clients)聽 聽 聽 聽 elif user == "E":聽 聽 聽 聽 聽 聽 menu\_activo = 0聽 聽 聽 聽 else: menu\_activo = 0 if \_\_name\_\_ == '\_\_main\_\_':聽 聽 run()

Ahora si vi la necesidad del + ',' en el replace, como se aprende de verdad aplicando a un proyecto.

En mi c贸digo decid铆 trabajar con listas en lugar de strings, principalmente para evitar lidiar con las comas. Tambi茅n hice la refactorizaci贸n para a帽adir una funci贸n que eval煤e si el nombre est谩 o no est谩 en la lista. Utilic茅 el m茅todo str.title() para hacer que los nombres sean indiferentes a may煤sculas o min煤sculas en el input (y con mira a implementar apellidos, eventualmente). As铆 est谩 quedando 馃槂

#!python3
clients = [
    'Raul',
    'Fernando',
    'Andres',
    'Sebastian',
    'Camilo',
    'Maria',
    'Angelica',
    'Giovanna',
    'Luisa'
]

def _assess_client_in_list(client_name):
    global clients
    if client_name.title() in clients:
        return True
    else:
        print('Client is not in clients list')

def create_client(client_name):
    global clients
    if client_name not in clients:
        clients += [client_name]
        print(f'Client {client_name} added to the list')
    else:
        print('Client already in the clients list')

def update_client(client_name, updated_client_name):
    global clients
    clients.remove(client_name) 
    clients.append(updated_client_name)


def delete_client(client_name):
    global clients
    clients.remove(client_name)
    print(f'{client_name} deleted from the list')


def list_clients():
    global clients
    print('\n')
    print(*clients, sep='\n\n')
    print('\n')


def _welcome():
    print('Welcome to this wonderful program!')
    print('*'*50+'\n')
    print('What would you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')
    print('[L]ist clients')
    print('[E]xit')

def _get_client_name():
    return input('What is the client name? ')


def _quick_menu():
    print('Please, enter a command:')
    print('[C]reate client | [U]pdate client | [D]elete client | [L]ist clients | [E]xit')


if __name__ == '__main__':
    _welcome()
    while True:
        command = input()
        command = command.upper()


        if command == 'C':
            client_name = _get_client_name()
            create_client(client_name)
            _quick_menu()
        elif command == 'U':
            client_name = _get_client_name()
            if _assess_client_in_list(client_name):
                updated_client_name = input('What is the new client name? ')
                update_client(client_name.title(), updated_client_name.title())
                print('This is the updated list of clients: ')
                list_clients()
            _quick_menu()
        elif command == 'D':
            client_name = _get_client_name()
            if _assess_client_in_list(client_name):
                delete_client(client_name.title())
            _quick_menu()
        elif command == 'L':
            print('This is the list of clients:')
            list_clients()
            _quick_menu()
        elif command == 'E':
            print('Thank you for using this program! Until the next time :)')
            break
        else:
            print('Command not found')
clients = "Pablo,Ricardo,"

def create_client(client_name):
    global clients

    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        print("Client already is in client's list")

def list_clients():
    global clients

    print(clients)


def update_client(client_name, update_client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name +",",update_client_name+",")
    else:
        print("Client is not in client list")

def delete_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name+",","")
    else:
        print("Client is not in clinet list")

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")

def _get_client_name():
    return input("What is the client name? ")

if __name__ == '__main__':
    _print_welcome()

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

    if command == "C":
        client_name = _get_client_name()
        create_client(client_name)
        list_clients()

    elif command == "D":
        client_name = _get_client_name()
        delete_client(client_name)
        print("The client "+ client_name + " a been delete")
        list_clients()

    elif command == "U":
        client_name = _get_client_name()
        update_client_name = input("What is the update client name? ")
        update_client(client_name, update_client_name)
        list_clients()
    else:
        print("Invalid command")

Me gusto mucho esta forma de estructurar el programa

*Asi resolvi el conflicto de que el nombre ingresado no tenga coma (para el caso de Update):

if client_name in clients.lower():
clients = clients.lower()
if 鈥,鈥 in client_name:
clients = clients.replace(client_name + 鈥,鈥, updated_client_name + 鈥,鈥)
else:
clients = clients.replace(client_name , updated_client_name)

Aqu铆 ya incluido la Funci贸n Eliminar (delete)

clients:str = 'Jesus, Daniel'

def create_client(client_name): # create_client crea un nuevo cliente
    global clients
    if client_name not in clients: # Si el cliente no existe, lo crea
        _add_comma()
        clients += client_name
        print (f'Cliente {client_name} Creado Satisfactoriamente')
    else: # Si el cliente ya existe, lo informa
        print(f'El Cliente {client_name} Ya Existe')

def delete_client(client_name): # Creo una funcion para eliminar un cliente
    global clients
    if client_name in clients:
        _add_comma()
        clients = clients.replace(client_name + ',', '')
        print (f'Cliente {client_name} Fue Eliminado Satisfactoriamente')
    else:
        print(f'El Cliente {client_name} No Existe')

def update_client(client_name, update_client_name): # Creo una funcion para actualizar el nombre del cliente
    global clients
    if client_name in clients:
        _add_comma()
        clients = clients.replace(client_name + ',', update_client_name + ',')
        print (f'Cliente {client_name} Fue Actualizado Satisfactoriamente a {update_client_name}')
    else:
        print(f'El Cliente {client_name} No Existe')


def list_cleints(): # list_cleints muestra los clientesa que existen
    global clients
    print('clientes:',clients)
   

def _add_comma(): # Agrega una coma al final de la lista de clientes
    global clients
    clients += ', '


def _print_welcome(): # Imprime un mensaje de bienvenida al usuario 
    print(' _________________________________________ ')
    print('|        Bievenido a Platzi Ventas        |')
    print('|-----------------------------------------|')
    print('|[C] - Crear cliente                      |')
    print('|[E] - Eliminar cliente                   |')
    print('|[A] - Actualizar cliente                 |')
    print('|[B] - Buscar cliente                     |')
    print('|[S] - Salir.                             |')
    print('|_________________________________________|')
    
    global command
    command = input('Ingresa una opcion: ').upper()
       
    return _get_client_action(command) # retorno el valor de la variable command y lo paso a la funcion _get_client_action

def _get_client_action(command): # Creo una Funci贸n para ejecutar las acciones de los clientes
      
    if command == 'C':
        list_cleints()
        client_name = _get_client_name()
        create_client(client_name)
        list_cleints()

    elif command == 'E':
        list_cleints()  
        client_name = _get_client_name()
        delete_client(client_name)
        list_cleints()
        pass

    elif command == 'A':
        list_cleints()
        client_name = _get_client_name()
        update_client_name = input('Ingresa el nuevo nombre del cliente: ')
        update_client(client_name ,update_client_name)
        list_cleints()
        

    elif command == 'B':
        pass

    elif command == 'S':
        pass
    else:
        print('                                         ')
        print(' __________Comando no encontrado__________')
      
        _print_welcome()

def _get_client_name(): # Creo una funcion para pedir el nombre del cliente
    client_name = input('Ingresa el nombre del cliente: ')
    return client_name


if __name__== '__main__':
    _print_welcome()

CRUD pero con listas

BD_client=['pablo','david']

def add_client(client_name):
    global BD_client
    
    if client_name not in BD_client:
        BD_client.append(str(client_name))
    else:
        print('The Client already is in the client\'s list')

def list_clients_DB():
    global BD_client
    print( str(BD_client))

def _update_client(client_name):
    global BD_client
    
    n=0
    if updated_client_name in BD_client:
        for  i in BD_client:
            
            if i == updated_client_name:
                BD_client[n] = str(input('New name for client: '))
                print('Client '+ BD_client[n] + ' was updated')
            n+=1
    else:
        print(updated_client_name + ' not found')
                

def _delete(delete_client_name):
    global BD_client
    
    n=0
    if delete_client_name in BD_client:
        for  i in BD_client:
            
            if i == delete_client_name:
                del(BD_client[n])
                print('Client '+ delete_client_name + ' was deleted')
            n+=1
    else:
        print(updated_client_name + ' not found')     
        
    
    
def _print_welcome():
    print('hola que hace?')
    print('*'*5)
    print('what would you like to do today?')
    print('[C]reate client')
    print('[D]elete client')
    print('[U]pdate client')
    
if __name__ == '__main__':
    
    _print_welcome()
    
    command = input()
    if command == 'C':
        client_name = input('What is the client name?: ')
        add_client(client_name)
        list_clients_DB()
        
    elif command == 'U':
        updated_client_name =str(input('What is the client name?: '))
        _update_client(updated_client_name)
        print(str(BD_client))
        
    elif command == 'D':
        delete_client_name =str(input('What is the client name?: '))
        _delete(delete_client_name)
        print(str(BD_client))
        
    else:
        print('Invalid command')

Para refactorizar el mensaje de que el cliente no se encuentra:

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

Me doy cuenta que todav铆a no llegamos a Listas, pero mi pregunta es saber que tan conveniente o 煤til es usar un string (en clase se us贸 el clients) que usar un lista


clients = 'pablo, ricardo, '

def create_client(client_name):
    global clients
    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        print('Client already is in the client\'s list')     

def update_client(client_name, update_cliente_name):
    global clients
    if client_name in clients:
        clients = clients.replace(client_name + ',', update_cliente_name + ',' )
    else:
        dont_exist()

def delete_client(client_name):
    global clients
    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        dont_exist()       

def list_clients():
    global clients
    print(clients)

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

def dont_exist():
    return 'Client is not in clients 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('[U]pdate Client')
    
def _get_client_name():
    return input('what is the client name?: ')

if __name__ == '__main__':
    _print_welcome()
    
    command = input()
    command = command.upper()
        
    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        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_name = input('What is the updated client name: ')
        update_client(client_name, update_client_name)
        list_clients()
    else:
        print('Invalid command')

No hacer acciones repetitivas, siempre hay una manera de automatizar las acciones.

mi soluci贸n a las cadenas de texto repetidas es crear un diccionario como variable global

labels ={
    'label1': 'client is already in the client\'s list ',
    'label2': 'client is not in client\'s list'
}

y luego solamente llamarlo dentro de la funci贸n respectiva, el diccionario puede ser reutilizado dentro de todo el programa

def delete_client(client_name):
    global clients
    global labels

    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        print(labels['label2'])

Por que solo me toma algunas partes del codigo?

clients = []
end_program = False

def show_clients():
global clients
num=0
print("*"*50)
print(鈥淐lient list:\n鈥)
for i in clients:
num+=1
print(f"\t{num})_ {i}")

def capitalize_name(client_name):

list_name = client_name.rsplit((" "))
index=0
for name in list_name:
    
    list_name[index]=name.capitalize()
    index+=1
    print(f"---procesing:{name}")
space= " "
client_name=space.join(list_name)
return client_name

def create_client():
global clients
client_name = input(鈥淚nsert the client name:鈥)
client_name=capitalize_name(client_name)

if client_name not in clients:

    clients.append(client_name)
    print(f"New user: {client_name} added successfully!")
else:
    print("The client is already in this db,please try again")
    create_client()
show_clients()

def delete_client():
global clients
print(鈥淪elect the name_client what you want delete:鈥)
show_clients()
index = int(input())
if (index >=0 and index <= len(clients)):
client_del=clients[index - 1]
print(f"Client deleted: {client_del}")
clients.remove(client_del)
return
else:
print(鈥淚ndex Error鈥)

def update_client():
global clients
print(鈥淪elect index to change the username:鈥)
show_clients()
client_num= int(input())
client_num = client_num-1
client_name = input(f"Insert the new username:")
client_name = capitalize_name(client_name)
num = client_num+1
print(f"{num}){clients[client_num]} ==> {client_name} \n")
clients[client_num]=client_name
show_clients()

def processing_option(option):
if option == 1:
create_client()

elif option ==2:

    update_client()
elif option == 3:
    delete_client()
elif option == 4:
    show_clients()

def _print_welcome():
global end_program
print(鈥淲elcome to Simopro server:鈥)
print("*"50)
print(鈥淪elect the option:鈥)
print("\t 1)_Insert new register")
print("\t 2)_Update one register")
print("\t 3)_Delete one register")
print("\t 4)_Show client list")
print("\t 5)_End program")
print("
"50)
option = int(input(鈥淐hosen option:鈥))
if option == 5:
end_program=True
print(鈥淧rogramm ending鈥︹)
print("
50)
print("
鈥*50)
return

processing_option(option)

def run():
while end_program ==False:
print(鈥渋nit鈥)
_print_welcome()

if name == 鈥main鈥:
run()

Me quedo con la frase y me gustar铆a resaltarla por ac谩 de 鈥渇actorizar funciones no s贸lo te permite reutilizar c贸digo sino que si se modifica con posterioridad lo podemos hacer en un s贸lo lugar y se modifica para todo el programa鈥.

Ahora es importante, tener esto en consideraci贸n ya que si va a afectar todo tu programa puede da帽arlo una modificaci贸n, y no conseguir bien donde esta el error.

para no repetir el mismo codigo h declarado arriba de clients una variable notclients = (鈥淐lient is not in clients list鈥)
y la llamo con global notclients de esta manera no repito codigo 馃槢

Excelente explicaci贸n, pese a todos, este lenguaje me gusta cada vez mas!

Actualizaci贸n del c贸digo:


clients = 'luisa, juan,'

def create_client(client_name):
	global clients

	if client_name not in clients :
		clients += client_name
		_add_comma()
	else:
		print ('Client already is in the client\'s list')

def list_clients():
	global clients

	print(clients)


def updated_client(client_name, updated_client_name):
	global clients

	if client_name in clients :
		clients = clients.replace (client_name + ',', updated_client_name + ',' )
	else:
		print ('Client is no it clients list')


def delete_client(client_name):
	global clients

	if client_name in clients:
		clients = clients.replace(client_name + ',', '')
	else:
		print('Client is not in clients list')

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]pdated client')
	print ('[D]elete client')


def _get_client_name ():
	return str.lower(input('What is the client name ? '))


if __name__ == '__main__':
	_print_welcome()

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

	if command == 'C':
		client_name = _get_client_name()
		create_client(client_name)
		list_clients()
	elif command == 'U':
		client_name = _get_client_name()
		updated_client_name = str.lower(input ('What is the updated client name ? '))
		updated_client(client_name, updated_client_name)
		list_clients()
	elif command == 'D':
		client_name = _get_client_name()
		delete_client(client_name)
		list_clients()
	else:
		print ('Invalid command')

hola comunidad, tengo una duda sobre la ejecuci贸n del c贸digo, lo tengo igual que el prof David, pero al ejecutar doy enter y solo me aparece como si no hubiera escrito nada en la terminal, alguien sabe lo que esta pasando?

Hola, yo a帽adi una funcion que me mostrara el mensaje que el cliente no existia

def _not_client_list_message(client_name):
	return print('The client ' + client_name +' is not in the client\'s list')```

*tengan en cuenta que el nombre debe de ser completo, ya que si ustedes ingresan unicamente una letra, esta la reconoce la primera ocurrencia y la reemplaza o la elimina.

Este es mi c贸digo con la ultima refactorizacion y agreg谩ndole una funcionalidad mas en la cual si escribes un nombre que no esta en la lista retorne el nombre que acabas de escribir

clients = 'pablo, ricardo, '


def create_client(client_name):
    global clients

    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        print('Client already in client\'s list')


def list_clients():
	global clients

	print(clients)


def update_client(client_name,updated_client_name):
	global clients

	if client_name in clients:
		clients = clients.replace(client_name + ",", updated_client_name)
	else:
		_not_in_clients(client_name)


def delete_client(client_name):
	global clients
	if client_name in clients:
		clients = clients.replace(client_name + ",", "")
	else:
		_not_in_clients(client_name)


def _get_client_name():
	return input("What is the client name? ")


def _not_in_clients(client_name):
	global clients
	if client_name not in clients:
		 print(client_name, "is not in client's list")


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


def _print_welcome():
	print("WELCOME TO LA BOOTS VENTAS")
	print("*" * 50)
	print("What would yo like to do today?")
	print("[C]reate client")
	print("[R]ead client")
	print("[U]pdate client")
	print("[D]elete client")


if __name__ == '__main__':
	_print_welcome()

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

	if command == "C":
		nombre_cliente = _get_client_name()
		create_client(nombre_cliente)
		list_clients()
	elif command == "R":
		list_clients()
	elif command == "D":
		nombre_cliente = _get_client_name()
		delete_client(nombre_cliente)
		_not_in_clients(nombre_cliente)
		list_clients()
	elif command == "U":
		nombre_cliente = _get_client_name()
		nombre_cliente_actualizado = input("What is the updated client name? ")
		update_client(nombre_cliente, nombre_cliente_actualizado)
		_not_in_clients(nombre_cliente)
		list_clients()
	else:
		print("Invalid command, try again")
Que pasa si al las funciones que piden nombre les damos como par谩metro directamente la funci贸n get

Aqui mi codigo

clients = 'pablo,ricardo,'


def create_client(client_name):
    # Permite usar una variable global dentro de la funcion
    global clients
    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        print("El cliente ya esta en la lista de clientes")


def list_clients():
    global clients
    print(clients)


def update_client(current_client_name, updated_client_name):
    global clients
    if client_name in clients:
        clients = clients.replace(current_client_name, updated_client_name)
    else:
        _print_client_not_found()


def delete_client(client_name):
    global clients
    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        _print_client_not_found()


def _print_client_not_found():
    print("Client not found on client list")


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


def _print_welcome():
    print('Bienvenidos a la app de ventas')
    print('*' * 50)
    print('驴Que quisieras hacer hoy?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')
    print('')


def _get_client_name():
    return input("驴Cual es el nombre del cliente? ")


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

    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif command == 'U':
        client_name = _get_client_name()
        new_client_name = input("What is the updated client name?")
        update_client(client_name, new_client_name)
        list_clients()
    else:
        print("Invalid command")

Los cambios a mi codigo

clients = 'Pablo, Ricardo, Pepe, Julio, '  # creamos el string


def create_client(client_name):
    global clients  # Utilizamos global para definir que la variable es la global, es decir la que definimos con pablo y ricardo
    if client_name not in clients:  # Condicion para saber si un cliente ya existe o no
        clients += client_name  # adicionamos el nuevo string
        _add_comma()  # ejecutamos la funcion _add_coma para agregar una coma y un espacio
    else:
        print('Client already is in the client\'s list')


def list_clients():
    """
        Funci贸n que muestra la lista de clientes
    """
    global clients

    print(clients)  # imprimimos el string clientes


def update_client(client_name):
    global clients

    if client_name in clients:
        updated_client_name = input('What is the updated client name?: ')
        clients = clients.replace(client_name + ', ', updated_client_name.capitalize() + ', ')
    else:
        _not_client_list(client_name)


def delete_cliente(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ', ', '')
    else:
        _not_client_list(client_name)


def _add_comma():
    """
        El nombre de la funci贸n comienza con un gui贸n bajo para
        establecer que ser谩 una funcion privada
    """
    global clients

    clients += ', '  # se agrega una coma y un espacio al string para separar los nuevos valores


def _print_welcome():
    print('WELCOME TO PLATZI VENTAS')
    print('*' * 50)
    print('What would yo like to do today?')
    print('[C]reate cliente')
    print('[U]pdate cliente')
    print('[D]elete cliente')
    print('')


def _get_client_name():
    """
        Guardamos en la variable client_name el valor de los caracteres que
        ingresa el usuario hasta recibir un enter
    """
    return input('What is the client name?: ')


def _not_client_list(client_name):
    print('The client "' + client_name + '" is not in client\'s list')


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

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

    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name.capitalize())
        list_clients()
    elif command == 'D':
        client_name = _get_client_name()
        delete_cliente(client_name.capitalize())
        list_clients()
    elif command == 'U':
        client_name = _get_client_name()
        # updated_client_name = input('What is the updated client name?: ')
        update_client(client_name.capitalize())
        list_clients()
    else:
        print('Invalid command')

Yo utilice un array para hacer la lista de clientes, me parecio mas eficiente y supongo que si no uso un array es porque ese tema se encuentra en otra seccion del curso llamada estructura de datos la cual se ve mas adelante.

Genial!! Me encant贸 la clase y el crud!

Aqui mi codigo refactorizado.!!


clients = 'pablo,ricardo,'

def create_client(client_name):
    global clients

    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        print('Client already is in the client\'s list')


def list_clients():
    global clients
    
    print(clients)


def update_client(client_name, updated_client_name):
    _replace_client(client_name, updated_client_name) 


def delete_client(client_name):
    _replace_client(client_name, "") 


def _replace_client(client_name, string_replace):
    global clients
     
    if client_name in clients:
        clients = clients.replace(client_name + ',' , string_replace) 
    else:
        print('Client is not clients list')


def _add_comma():
    global clients

    clients += ','


def _get_client_name():
    return input('What is the client name? ')


def _print_welcome():
    print('WELCOME TO SALES APP')
    print('*' * 50)
    print('What would you like to do today?')
    print('[C]reate client')
    print('[U]pdate client')
    print('[D]elete client')


if __name__ == '__main__':
    _print_welcome()

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

    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        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('What is the updated client name ')
        update_client(client_name, updated_client_name)
        list_clients()
    else:
        print('Invalid command')

Hice una verison mucho mas legible que el de la clase. El del profe me parecio un tanto desordenada

#CRUD pattern with clients

clients = 'Ricardo, Pedro, Jason, '

def create_client(client_name):
    global clients
    _add_comma(client_name)
    clients += client_name

def update_client(client_name, new_client_name):
    global clients
    clients = clients.replace(client_name, new_client_name)
    _add_comma(new_client_name)


def delete_client(client_name):
    global clients
    clients = clients.replace(client_name, '')


def _add_comma(client_name):
    client_name += ', '


def list_clients():
    global clients
    print(clients)

print("Welcome to the client database")
print('What do you wish to do?')
print('[C]reate a client')
print('[R]etrieve a client')
print('[U]pdate a client')
print('[D]elete a client')
user_command = input()
command = user_command.upper()
print('*' * 50)


def get_client_name():
     client_name = input("What is your client's name? ").capitalize()
     return client_name

def _command_success():
    print('Succesful.')

def client_not_found():
    print('Client does not exist.')


if command == 'C':
    client_name = get_client_name()
    create_client(client_name)
    _command_success()
elif command == 'R':
    pass
elif command == 'U':
    client_name = get_client_name()
    if client_name in clients:
        new_client_name = input("What is your new client's name? ").capitalize()
        update_client(client_name, new_client_name)
        _command_success()
    else: client_not_found()
elif command == 'D':
    client_name = get_client_name()
    if client_name in clients:
        delete_client(client_name)
        _command_success()
    else: client_not_found()

else: print("we cannot help you")


if __name__ == '__main__':
        list_clients()

Con este c贸digo no hay distinci贸n entre may煤sculas y min煤sculas (lo cual evita problemas a la hora de hacer los inputs y buscar) y utiliza listas, las cuales me parecen la forma m谩s 贸ptima.

clients = ['pablo', 'ricardo']

def welcome():
        print('Welcome!',
              '*'*20,
              'What would you like to do?',
              'C -> Create client',
              'U -> Update client',
              'D -> Delete client',
              '>>>',
              sep='\n', end=' ')


def create_client(client_name):
    global clients # Take global variable clients to use it
    client_name = client_name.lower()

    if client_name not in clients:
        clients.append(client_name) # Add element client_name to the list
    else:
        print('{client} is already in the client\'s list'.format(client=client_name))

def list_clients():
    """Join the elements of the list clients through the string ', ' """
    global clients
    clients = [client.capitalize() for client in clients]
    print(', '.join(clients))

def update_client(client_name):
    global clients
    client_name = client_name.lower()

    if client_name in clients:
        updated_client_name = input('What is the updated client name:\n>>> ')
        client_index = clients.index(client_name)
        clients[client_index] = updated_client_name
        return
    print('Client is not in clients list')

def delete_client(client_name):
    global clients
    client_name = client_name.lower()

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

def _get_client_name():
    return input('What is the client name?:\n>>> ')

if __name__ == '__main__':
    welcome()

    user_decision = input()
    user_decision = user_decision.upper()

    if user_decision == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        list_clients()
    elif user_decision == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif user_decision == 'U':
        client_name = _get_client_name()
        update_client(client_name)
        list_clients()
    else:
        print('Invalid command')

Lo arregl茅 para que no hayan problemas si el usuario escribe con may煤sculas o min煤sculas.



def _put_uppercase(word):
	return word.upper()


clients = 'pablo,ricardo,'
clients=_put_uppercase(clients)

def create_client(client_name): 
	global clients
	client_name=_put_uppercase(client_name)
	if client_name not in clients: # verify that the client is not
		clients += client_name #add the client to the list
		_add_comma()
	else:
		print('Client already is in client\'s list')


def list_clients():
	global clients

	print(clients)


def update_client(client_name,update_client_name):
	global clients
	client_name=_put_uppercase(client_name)
	update_client_name=_put_uppercase(update_client_name)
	if client_name in clients:
		clients = clients.replace(client_name , update_client_name)
	else:
		_print_client_is_not()


def delete_client(client_name):
	global clients
	client_name=_put_uppercase(client_name)
	if client_name in clients:
		clients=clients.replace(client_name + ',','')
	else:
		_print_client_is_not()


def _put_uppercase(word):
	return word.upper()
	

def _print_client_is_not():
	return print('Client is not in cllients list')


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


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


def _get_client_name():
	return input('What is the client name ')

if __name__=='__main__':
	_print_welcome()
	
	command = input()
	command=_put_uppercase(command)

	if command == 'C':
		create_client(_get_client_name())
		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_name = input('What is the update client name ')
		update_client(client_name,update_client_name)
		list_clients()
	elif command == 'L':
		list_clients()
	else:
		print('Invalid command')```

Funci贸n para el print del client no registrado

def delete_client(client_name):
    global clients
    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        _not_registered_client()

def _not_registered_client():
    print('Client is not in clients list')

Optimizando un poco el mensaje

def delete_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else: 
        _not_exist_client()

def _not_exist_client():
    print('Client is not in client list ')

Mi codigo esta cada vivo!!!

Excelente clase, bien explicado

CRUD



tengo problemas para cambiar el nombre, ya que no lo cambia si no lo borra, mas bien no imprime el nuevo nombre

def _not_client_name():
return input(鈥楥lient is not in client list鈥)

Va tomando forma !

Comparto mi codigo

def search_client(client_name):
    global clients
    end_name = len(client_name)
    end_string = len(clients)
    find_name = clients.find(client_name)
    return clients.find(",", find_name, end_name + 1) > 0 or find_name + end_name == end_string


def update_client(client_name, updated_name):
    global clients
    client_name = client_name.strip()
    updated_name = updated_name.strip()
    client_exist = search_client(client_name)
    if client_exist:
        clients = clients.replace(client_name, updated_name)
    else:
        _client_not_exist(client_name)


def delete_client(client_name):
    global clients
    client_name = client_name.strip()
    client_exist = search_client(client_name)
    find_name = clients.find(client_name)
    if client_exist:
        if find_name == 0:
            clients = clients.replace(client_name + ", " , "" )
        else:
            clients = clients.replace(", " + client_name, "" )
    else:
        _client_not_exist(client_name)


def _client_not_exist(client_name):
    print("I don't found " + client_name + " in the client's list")

Mi codigo


clients = 'osvaldo, ricardo,'

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


    _add_comma()

def _add_comma():
    global clients

    clients += ' ,'


def list_clients():
    print(clients.title())


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


def _get_client_name():
    return input('What is the client name? : ')


def _get_message(kind_of_message):
    if(kind_of_message == 'refuse') :
        return print('Client is not in clients list')


def update_client(client_name, updated_client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name, updated_client_name)
    else:
        _get_message('refuse')


def _delete_client(client_name):
    global clients
    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        _get_message('refuse')



if __name__ == '__main__':
    print_welcome()

    command = input().upper()

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

    elif command == 'U':
        client_name = _get_client_name()
        update_client_name = input('what is the updated client name? : ')
        update_client(client_name, update_client_name)

        list_clients()
    else:
        print('Invalid comman')

Mi codigo con algunos comentarios

clients = 'pablo, ricardo, '

#Crear CLientes
def create_client(client_name):
    global clients #variable global y s epuede usar dentro de la funcion
    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        _not_in_list()

#Listar clientes
def list_clients():
    global clients
    print (clients)

#Actualizar el cliente
def update_client(client_name, updated_client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ', ', updated_client_name + ', ')
    else:
        _not_in_list()

#Borrar cliente
def delete_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ', ', '')
    else:
        _not_in_list()

#A帽adir una coma
def _add_comma():
    global clients
    clients += ','

#Pantalla de menu
def _print_welcome():
    print('WELCOME TO SALES')
    print('*'*50)
    print('What would like to do? ')
    print('[C]reate client')
    print('[D]elete client')
    print('[U]pdate client')

#Obtener el nombre del cliente
def _get_client_name():
    return input('What\'s client name: ')

#mensajes sin interaccion
def _not_in_list():
    print('Client not in list')

#Main
if __name__ == "__main__":
    _print_welcome()
#Pedir al usuario opcion
    command = input('')
    if command.lower() == 'c':
        client_name = _get_client_name()
        create_client(client_name)
        list_clients()
    elif command.lower() == 'd':
        client_name = _get_client_name()
        delete_client(client_name)
        list_clients()
    elif  command.lower() == 'u':
        client_name = _get_client_name()
        updated_client_name = input('What\'s the updated client name==> ')
        update_client(client_name, updated_client_name)
        list_clients()
    else:
        print('Invalid command!! ')

Por ac谩 dejo mi c贸digo

#!/usr/bin/env python
"""
Platzi Ventas Project for DULC in the Client List
"""


def _error_message():
    print('Client is not in the list')


def _create_client(clients):
    name = _get_client_name(False)
    if name not in clients:
        clients += ',' + name
    else:
        print('Client already is in the client list')
    print(clients)
    return clients


def _update_client(clients):
    old_name = _get_client_name(False)
    if old_name in clients:
        new_name = _get_client_name(True)
        clients = clients.replace(old_name, new_name)
    else:
        _error_message()
    print(clients)
    return clients


def _delete_client(clients):
    name = _get_client_name(False)
    if name in clients:
        clients = clients.replace(name, '')
        clients = _clean_commas(clients)
    else:
        _error_message()
    print(clients)
    return clients


def _clean_commas(clients):
    if clients.startswith(','):
        clients = clients[1:]
    elif clients.endswith(','):
        clients = clients[0:-1]
    return clients


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


def _get_client_name(get_new):
    if get_new:
        return input('What is the new client name? ')
    return input('What is the client name? ')


if __name__ == '__main__':
    CLIENTS = 'Pablo,Ricardo'
    _welcome()
    COMMAND = input()
    COMMAND = COMMAND.upper()
    if COMMAND == 'D':
        CLIENTS = _delete_client(CLIENTS)
    elif COMMAND == 'U':
        CLIENTS = _update_client(CLIENTS)
    elif COMMAND == 'L':
        print(CLIENTS)
    elif COMMAND == 'C':
        CLIENTS = _create_client(CLIENTS)
    else:
        print('Invalid command')

Simplificar en una funci贸n

def _get_client_not_register():
    print('Client is not in clients list')

Entendido. Optimizar el mensaje

def delete_client(client_name):
    global clients
    if client_name in clients:
        clients = clients.replace(client_name + ',', '')
    else:
        _return_message()


def _return_message():
    print('掳' * 70)
    print('Client is not in client\'s list')

Cordial Saludo, envio codigo con ajustes en los avisos de que el nombre no existe

clients = 'Pablo, Ricardo, ' # Nombres iniciales

def create_client(client_name):# Crea nuevos clientes
    global clients  #Podemos tomar la variable global dentro de la funcion
    
    if client_name not in clients: # Si el nuevo cliente no esta en la lista
        clients += client_name # Lo adiciona
        _add_comma() #agrega coma   
    else: #Si esta en la lista
        print('Client already is in the client\'s list') # Muestra aviso
    
def list_clients(): #lista los clientes actuales
    global clients
    print (clients)


def update_client(client_name, updated_client_name): ## funcion de actualizacion
    global clients
    
    if client_name in clients:
        updated_client_name = input('What is the updated client name? ') 
        clients = clients.replace(client_name + ',', updated_client_name + ',' )        
    else:
        alert_empty()


def delete_client(client_name):
    global clients
    
    if client_name in clients:
        clients = clients.replace(client_name + ',','') # Reemplazo por String Vacion
        
    else:
        #print('Client is not in client\'s list') # Muestra aviso
        alert_empty()

def alert_empty():
    return print('Client is not in client\'s list') # Muestra aviso



#Recomendable: Dejar 2 espacios entre funciones
def _add_comma(): #funcion auxiliar para agregar comas
    global clients
    clients += ', '


def _print_welcome(): #Mensaje de Bienvenida
    print('='*50)
    print("Bienvenidos a PlatziVentas!!!")
    print('='*50)
    print("What would you like to do today?") # Menu de bievenida
    print("[C]reate Client")
    print("[U]pdate Client")
    print("[D]elete Client")
    
    
def _getc_client_name(): # Funcion auxiliar para traer el nombre del cliente
    return input('What is the client name? ') # Lee el nombre del cliente en el input
    

############################ Programa Principal ################################

if __name__ == '__main__': # Punto de partida/programa principal
    _print_welcome() # Llama mensaje de Bienvenida
    command = input() # Detiene la ejecucion del programa hasta que el usuario inserte el valor
    commnad = command.upper #la opcion del usuario la vuelve mayuscula
    
    if command == 'C': # Si se cumple esta opcion
        client_name = _getc_client_name()
        create_client(client_name) # Crea el cliente
        list_clients() #Lista los clientes actuales
        
    elif command == 'D': #Si se cumple esta opcion
        client_name = _getc_client_name()
        delete_client(client_name)
        list_clients()
        
    elif command == 'U': # Si se cumple esta opcion
        client_name = _getc_client_name()
        ##updated_client_name = input('What is the updated client name? ') 
        update_client(client_name, updated_client_name)
        list_clients() 
    
    else:
        print ('Invalid command!!!') #Imprime este aviso

Usando la funcion .capitalize, se puede evitar el programa falle cuando se ingresa un nombre q inicie en minuscula.

<clients = 'Pablo, Ricardo,'

def create_client(client_name):
    global clients

    if client_name not in clients:
        clients += client_name
        _add_coma()
    else:
        print('Client already is in de client\'s list')

def list_clients():
    global clients
    print(clients)

def update_client(client_name, updated_client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',', updated_client_name + ',')
    else:
        print('Client is not in client\'s list')

def delete_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',' , " ") #Agrgamos un string vacion con ( " " )
    else:
        print('Client is not in client\'s list')

def _add_coma():
    global clients

    clients += ','

def _print_welcome():
    print('WELCOME PLATZI VENTAS')
    print('*' * 50)
    print('Whats would you like to do today: ')
    print('[C] - Create Clients')
    print('[U] Update Clients')
    print('[D] - Delete Clients')

def _get_client_name():
    return input('What is the client name?')

if __name__ == '__main__':
    _print_welcome()

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

    if command == 'C':
        client_name = _get_client_name()
        client_name = client_name.capitalize()
        create_client(client_name)
        list_clients()

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

    elif command == 'U':
        client_name = _get_client_name()
        client_name = client_name.capitalize()
        update_client_name = input('What is the update client name')
        update_client_name = update_client_name.capitalize()
        update_client(client_name, update_client_name)
        list_clients()

    else:
        print('Invalid Command')
>

Excelente introducci贸n al concepto de CRUD. Con 茅ste script se entiende bien la estructura.

Buen d铆a compa帽eros鈥
Yo intent茅 algo muy complicado para solucionar el delete y me surgi贸 un problema que me parece muy intersante.

basicamente paso el string a un arreglo con split y despu茅s borro el elemento del arreglo con remove para despues volver a transformar este arreglo en un string y ese resultado asignarlo a la variable global de la cadena clientes de la siguiente manera:

def delete_client(name):
global clientes
global namesl
if name not in clientes:
print(鈥楾his client is not exist鈥)
elif name in clientes:
namesl=clientes.split(鈥,鈥)
namesl=namesl.remove(name)
aux=鈥'
for i in range(len(len(namesl))):
aux+=namesl[i]
clientes=aux

Y al correr esta l贸gica en la terminal de python funciona a la perfecci贸n. Pero al utilizarla en el archivo main.py sale el siguiente error:

What do you like to day
[C] create client
[D] delete client
D
What is the name of clien that you want to delete?
david
Traceback (most recent call last):
File 鈥main.py鈥, line 65, in <module>
delete_client(_name_client)
File 鈥main.py鈥, line 47, in delete_client
for i in range(len(len(namesl))):
TypeError: object of type 鈥楴oneType鈥 has no len()

Ya hice una asignaci贸n explicita del arreglo namesl y tambi茅n lo declare como variable global pero nada de eso funcion贸. Les agradecer铆a mucho que me ayudaran a aclarar este asunto.

my challenge solution

clients = 'pablo,ricardo,'

def create_client(client_name):
    global clients
    if client_name not in clients:
        clients += client_name
        _add_comma()
    else:
        get_message_client_exist(True)

def list_clients():
    global clients

    print(clients)

def update_client(client_name, updated_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',', updated_name + ',')
    else:
        get_message_client_exist(False)

def delete_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',' ,"")
    else:
        get_message_client_exist(False)

def _add_comma():
    global clients

    clients += ','

def _get_client_name():
    return input('What is the client name?')

def get_message_client_exist(mod):
    if (mod):
        return print('Client already in client\'s list')
    else:
        return print('Client 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('[U]pdate client')
    print('[D]elate client')


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

    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        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 new client name?')
        update_client(client_name, updated_name)
        list_clients()
    else:
        print('Invalid command')

Yo no constru铆 la funcion get_client_name por una simple raz贸n鈥 No me pareci贸 bonito para el usuario XD, se que para el programador es mas sencillo unicamente pedir un nombre, pero si no se especifica para qu茅 es puede darse para errores鈥 puede que el usuario quisiera agregar un nuevo nombre y no actualizarlo鈥 al poner en la solicitud para que es el nombre no solo se ve mas bonito sino que se previenen errores de usuario!!! esta es mi no tan humilde opini贸n! 馃槃

la funcion de _get_client_id() se le puede agregar un par谩metro para que solo sea llamarla con el mesaje que queremos:
_get_client_id(msg)

Les comparto mi codigo, defini la funcion _not_client_name para imprimir el mensaje cuando el nombre del cliente no fue encontrado en la lista

# -*- codign: utf-8 -*-
clients = 'pablo,ricardo,'


def create_client(client_name):
	global clients

	if client_name not in clients:
		clients += client_name 
		_add_comma()
	else:
		print('Client already is in the client\'s list')


def list_clients():
	global clients

	print(clients)


def update_client(client_name, update_client_name):
	global clients

	if client_name in clients:
		clients = clients.replace(client_name + ',', update_client_name + ',')
	else:
		_not_client_name()


def delete_client(client_name):
	global clients

	if client_name in clients:
		clients = clients.replace(client_name + ',','')

	else:
		_not_client_name()


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 clients')
	print('[U]pdate clients')
	print('[D]elete clients')
	

def _get_client_name():
	return raw_input('What is the client name')


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


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

	if command == 'C':
		client_name = _get_client_name()
		create_client(client_name)
		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_name = raw_input('What is the update client name')
		update_client(client_name, update_client_name)
		list_clients()
	else:
		print('Invalid command')
<code>
clients = ("Constansa, Fernanda, Marzia, Camila, ")


def create_client(new_client):
    global clients
    clients += new_client
    _add_coma()

def update_client(new_client, update_client_name):
    global clients

    if new_client in clients:
        clients = clients.replace(new_client + ", ", update_client_name + ", ")
    else:
        not_found()
    

def delete_client(new_client):
    global clients

    if new_client in clients:
        clients = clients.replace(new_client + ", ", "")
    else:
        not_found()

def _add_coma():
    global clients
    clients += ", "

def list_client():
    print(clients)

def welcome():
    print("""
    WElCOME TO PLATZI VENTAS
    
    [C]reate new client
    [D]etele client
    [U]pdate client
    [L]ist of client
    [R]eplace of client
    """)

def not_found():
    print("client is nor found ")

def _get_client_name():
    return input("What is the client name? ")

if __name__ == "__main__":
    welcome()

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

    if command == "C":
        new_client = _get_client_name()
        create_client(new_client)
        list_client()

    elif command == "D":
        new_client = _get_client_name()
        delete_client(new_client)
        list_client()
    
    elif command == "U":
        new_client = _get_client_name()
        update_client_name = input("What is new client name? ")
        update_client(new_client, update_client_name)
        list_client()

    else:
        not_found()
     

hey queria hacer un loop que se repitiera cada vez que el usuario quisiera hacer algo mas pero no me recibe el comando

clients = 'Jean, Victor, Carla,'

def create_client(client_name):
    global clients

    if client_name not in clients:
        clients += ', ' + client_name
        _add_comma()
    else:
        print('Client already exist in the client\'s list')


def list_clients():
    global clients

    print(clients)


def update_client(client_name):
    global clients
    if client_name in clients:
        updated_client_name = input('what is the updated client name?')
        clients = clients.replace(client_name + ',', updated_client_name + ',')
    else:
        print('client is not in clietns list')


def delete_client(client_name):
    global clients
    if client_name in clients:
        delete_client_name = client_name
        clients = clients.replace(client_name + ', ', '')
    else:
        print('client is not in clietns list')


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('[D]elete client')
    print('[U]pdate client')


def _print_q():
    print('WANT TO DO SOMETHING MORE? (Y/N)')


def _get_client_name():
    return input('What is the client name?')


if __name__ == '__main__':

    def get_command():
        command = input().upper()   
        return command


    def CRUD():
    
        if get_command() == 'C':
            client_name = _get_client_name()
            create_client(client_name)
            list_clients()
        elif get_command() == 'D':
            client_name = _get_client_name()
            delete_client(client_name)
            list_clients()
        elif get_command() == 'U':
            client_name = _get_client_name()
            update_client(client_name)
            list_clients()
        else:
            print('Invalid command')


    def loop():
        com = get_command()

        if  com == 'Y':
            CRUD()
        elif com == 'N':
            pass
        else:
            print('Invalid command')


    _print_welcome()
    
    CRUD()

    _print_q()
    
    loop()

Hice una refactorizacion basica del mensaje cuando el cliente no existe en el registro:

    else:
        dont_exist()

def dont_exist():
    return f'that client is not register'

excelente, si mi duda era esa como lo guardaba ajaj sigamos

Funcion de borrar cliente

def delete_client(client_name):
    global clients

    if client_name in clients:
        clients = clients.replace(client_name + ',', '')

    else:
        _print_message_client()

Don鈥檛 Repeat Yourself

.
Uno de los principios utilizado en el dise帽o de software, que significa 隆no te repitas! tambi茅n conocido como Una vez y s贸lo una.
.

.
Seg煤n este principio toda "pieza de informaci贸n" nunca deber铆a ser duplicada debido a que la duplicaci贸n incrementa la dificultad en los cambios y evoluci贸n posterior, puede perjudicar la claridad y crear un espacio para posibles inconsistencias. Los t茅rminos 鈥減ieza de informaci贸n鈥 son usados en un sentido amplio, abarcando:
.

  • datos almacenados en una base de datos;
  • c贸digo fuente de un programa de software;
  • informaci贸n textual o documentaci贸n.
    .
    Cuando el principio DRY se aplica de forma eficiente los cambios en cualquier parte del proceso requieren cambios en un 煤nico lugar. Por el contrario, si algunas partes del proceso est谩n repetidas por varios sitios, los cambios pueden provocar fallos con mayor facilidad si todos los sitios en los que aparece no se encuentran sincronizados.
    .

Los Principios en el dise帽o del software m谩s 煤tilizados: KISS, DRY y SOLID

.

驴Qu茅 es KISS?

.

.
Es un acr贸nimo de la frase inglesa 鈥淜eep it simple, Stupid!鈥
.
Este patr贸n lo que nos dice es que cualquier sistema va a funcionar mejor si se mantiene sencillo que si se vuelve complejo. Es decir que la sencillez tiene que ser una meta en el desarrollo y que la complejidad innecesaria debe ser eliminada.
.

驴Qu茅 es SOLID?

.
Son seis principios del desarrollo orientado a objetos que aplicados juntos facilitan que el desarrollo sea m谩s f谩cil de mantener y de extender durante el tiempo:
.
Principio de responsabilidad 煤nica (Single responsibility principle)
.
Este principio establece que una clase solo debe tener una responsabilidad sobre el total de la funcionalidad, es decir que para contener el cambio debemos de tener claramente definidas las responsabilidades.
.
Principio de abierto/cerrado (Open/closed principle)
.
Una clase est谩 cerrada a la modificaci贸n, pero abierta para extenderla. Es decir la clase abstracta o interfaz queda cerrada a la modificaci贸n, pero est谩 abierta a su extensi贸n o implementaci贸n de la interfaz.
.
Principio de sustituci贸n de Liskov (Liskov substitution principle)
.
Cada clase que hereda de otra puede usarse como su padre sin necesidad de conocer las diferencias entre ellas. Es decir que si una clase es un subtipo de otra, los objetos de esta clase subtipo podr铆an sustituir a los objetos de la clase padre sin que el programa sufriera ning煤n cambio de comportamiento.
.
Principio de segregaci贸n de la interfaz (Interface segregation principle)
.
Dice que los clientes de un programa dado s贸lo deber铆an conocer de 茅ste aquellos m茅todos que realmente usan. Para esto no se deben hacer interfaces de prop贸sito general si esto ocurre habr谩 que dividirlas en varias interfaces para cada prop贸sito espec铆fico.
.
Este principio lo que nos facilita es tener un sistema desacoplado de los sistemas de los que depende, de forma que sea m谩s f谩cil modificarlo, redesplegarlo.
.
Principio de inversi贸n de la dependencia (Dependency inversion principle)
.
Dice que se debe de depender de abstracciones no de implementaciones. Se le llama as铆 porque se invierte el flujo tradicional de programaci贸n mientras que tradicionalmente era el programador que de forma secuencial decid铆a cuando se iban instanciando las clases ahora lo que ocurre que determinadas sucesos provocan que a trav茅s de un entidad externa en este caso un framework se lleven a cabo las acciones de control necesarias para responder estos sucesos.
La inyecci贸n de dependencias
.
Es un m茅todo que sigue este principio, hay bastante confusi贸n con respecto a estos dos t茅rminos no son lo mismo.
.
T铆picamente la forma de implementarlo es a trav茅s de un framework que pone un contenedor de objetos que se van instanciando de forma autom谩tica siguiendo una configuraci贸n que est谩 especificada en un archivo de configuraci贸n de ese framework.

Los ejemplos pr谩cticos son lo mejor, muchas gracias

CRUD es el acr贸nimo de 鈥淐rear, Leer, Actualizar y Borrar鈥 (del ingl茅s: Create, Read, Update and Delete)

Les comparto mi c贸digo, coloque todos los mensajes en funciones separadas para que puedan reutilizarse y en un futuro (cuando sepa hacerlo) poder internacionalizarlos.

Las funciones que no CREATE, UPDATE o DELETE las hice privadas鈥 no estoy muy seguro si eso es correcto.

Si alguien sabe cual es la regla para definir que deber铆a ser publico y que no dejenme un comentario por favor.

# Variables globales
clients = 'Pablo,Ricardo,'


# Funciones principales CRUD
def create_client(client_name):
    global clients                  # Las funciones no pueden acceder a las variables globales a menos que se especifique

    if _check_client_existence(client_name):
        _message_client_exists()
    else:
        clients += client_name
        _add_comma()


def update_client(client_name):
    global clients

    if _check_client_existence(client_name):
        updated_client_name = _get_new_client_name()
        clients = clients.replace(client_name, updated_client_name)
    else:
        _message_client_doesnt_exists()

        # Si el cliente no existe preguntar si desea crearse
        create_new_client = _confirm_client_creation()

        if create_new_client == 'Y':
            create_client(client_name)
        else:
            pass


def delete_client(client_name):
    global clients

    if _check_client_existence(client_name):
        clients = clients.replace(client_name + ',', '')
    else:
        _message_client_doesnt_exists()


# Funciones extras
def _clients_list():
    global clients

    print('\n')
    print(clients)


def _check_client_existence(client_name):
    global clients

    client_exists = False
    if client_name in clients:
        client_exists = True
    else:
        client_exists = False

    return client_exists


def _get_input_command():
    command = input()
    command = command.upper()

    return command


def _add_comma():
    global clients

    clients += ','


# Funciones con mensajes por internacionalizar
def _get_client_name():
    return input('Type the client name\n')


def _get_new_client_name():
    return input('Type the new client name\n')


def _message_client_exists():
    return print('Client already exists')


def _message_client_doesnt_exists():
    return print('Client doesn\'t exists')


def _confirm_client_creation():
    print('\nDo you want to create a new client?')
    print('[Y]es')
    print('[N]o')

    return _get_input_command()


def _message_invalid_command():
    return print('\nInvalid command')


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')


# Programa principal
if __name__ == '__main__':
    _print_welcome()

    command = _get_input_command()

    if command == 'C':
        client_name = _get_client_name()
        create_client(client_name)
        _clients_list()
    elif command == 'U':
        client_name = _get_client_name()
        update_client(client_name)
        _clients_list()
    elif command == 'D':
        client_name = _get_client_name()
        delete_client(client_name)
        _clients_list()
    else:
        _message_invalid_command()