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.
Básicos del Lenguaje
Guía de instalación y conceptos básicos
Archivos y slides del curso práctico de Python
IMPORTANTE: Instalando Ubuntu Bash en Windows para facilitarte el seguimiento del curso desde Windows.
¿Qué es la programación?
¿Por qué programar con Python?
Operadores matemáticos
Variables y expresiones
Presentación del proyecto
Funciones
Usando funciones en nuestro proyecto
Operadores lógicos
Estructuras condicionales
Uso de strings y ciclos
Strings en Python
Operaciones con Strings en Python
Operaciones con strings y el comando Update
Operaciones con strings y el comando Delete
Operaciones con strings: Slices en python
For loops
While loops
Iterators and generators
Estructuras de Datos
Uso de listas
Operaciones con listas
Agregando listas a nuestro proyecto
Diccionarios
Agregando diccionarios a nuestro proyecto
Tuplas y conjuntos
Tuplas y conjuntos en código
Introducción al módulo collections
Python comprehensions
Búsquedas binarias
Continuando con las Búsquedas Binarias
Manipulación de archivos en Python 3
Uso de objetos y módulos
Decoradores
Decoradores en Python
¿Qué es la programación orientada a objetos?
Programación orientada a objetos en Python
Scopes and namespaces
Introducción a Click
Definición a la API pública
Clients
Servicios: Lógica de negocio de nuestra aplicación
Interface de create: Comunicación entre servicios y el cliente
Actualización de cliente
Interface de actualización
Manejo de errores y jerarquía de errores en Python
Context managers
Python en el mundo real
Aplicaciones de Python en el mundo real
Conclusiones finales
Python 2 vs 3 (Conclusiones)
Clases bonus
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
Si ya tienes una cuenta,
Operaciones con strings y el comando Delete
16/49Recursos
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:
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 “clients”, 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 “VAMOS 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 “Client is not in the List”. Aunque yo lo puse como “The 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.
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(“Client 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(“Insert 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(“Select 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(“Index Error”)
def update_client():
global clients
print(“Select 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(“Welcome to Simopro server:”)
print("*"50)
print(“Select 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(“Chosen option:”))
if option == 5:
end_program=True
print(“Programm ending…”)
print("“50)
print("”*50)
return
processing_option(option)
def run():
while end_program ==False:
print(“init”)
_print_welcome()
if name == ‘main’:
run()
Me quedo con la frase y me gustaría resaltarla por acá de “factorizar 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 = (“Client 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(‘Client 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(‘This 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 ‘NoneType’ 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
![Francisco Garcia [C6]](https://static.platzi.com/media/avatars/avatars/garciafran_c845c2fe-2ea4-42db-a305-a7f4ef13b0fd.jpeg)
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’t 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 “pieza 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 “Keep 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 “Crear, 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()
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?