DEV Community: Ricardo Aguilar

Python tutorial básico: Programando un registro.

Ricardo Aguilar — Mon, 13 Sep 2021 23:47:07 +0000

Escribiremos un programa que nos permita hacer un registro de animales, con su nombre científico
y su nombre común, estos enlazados por un ID único. Usando ese ID podremos eliminar al animal del registro,
o simplemente modificar los nombres ya escritos. Así como una opción de ver la lista de los animales ya
registrados y una opción que nos permita salir del programa.

La meta es generar e imprimir una lista que se pueda modificar como esta:

	Animal Registry
ID	Scientific Name	Common Name
3Y99	Canis Lupus Familiaris	Siberian Husky
MT5R	Cebinae	Capuchin Monkey
8D6U	Octopoda	Octopus
YG0E	Anthophila	Bee
JN14	Dinastinae	Rhinoceros Beetle
WVTA	Python Regius	Ball Python
HAZP	Gorilla	Gorilla

Trabajaremos con:

El modulo PrettyTable.
Diccionarios anidados.
Control del flujo.
Funciones.

Debes instalar PrettyTable mediante Pip.
Intenta, en la consola, con:
pip install prettytable

Primero, importaremos los módulos necesarios:
PrettyTable para la creación de la tabla en donde registraremos a los animales, random y string para
generar un ID al azar con el cual identificaremos la fila en el registo y sys para salir del programa.

from prettytable import PrettyTable
import random
import string
import sys

Ahora crearemos un diccionario vacío en donde almacenaremos los animales que vayamos a registrar.

animal_dic = {}

Escribiremos la condicional "if name == "main"" para evitar errores de importación y por buenas practicas.
y llamamos a nuestra función main().

if __name__ == "__main__":
    main()

La explicación de como if _name_ == "_main_" funciona está fuera del alcance de este articulo.

Funciones:

Ahora bien, escribamos las funciones que harán andar nuestro programa, estas, irán ANTES de la condicional "if _name_ == "_main_"" anteriormente descrito. De lo contrario Python intentaría ejecutar la función main() cuando esta no han sido definida, por lo tanto dispararía un error.

Función pricipal main:

Dentro de main() obligaremos a que se ejecute este loop con un while True,
imprimirá las instrucciones de añadir, borrar, actualizar, chequear y salir del programa.
También tenemos un input() que será la opción que elija el usuario y esta será almacenada en
la variable user_input. Atento al método .lower(), este convierte en minúsculas lo que ingrese el usuario, así evitamos errores de tipeo por parte de este. Finalmente, las condicionales. Dependiendo de lo que elija el usuario se llamará a una función.

# ~~~~~~~~~~~~~~~~~~ Functions(): ~~~~~~~~~~~~~~~~~~~
def main():
    # ~~~~~~~~~~~~~~ User's choise ~~~~~~~~~~~~~~~
    while True:
        instrucctions()
        user_input = input("\nWhat do you want to do? "
                           "(a, d, u, l, e): ").lower()
        if user_input == "a":
            add_animal()
        elif user_input == "d":
            delete_animal()
        elif user_input == "u":
            update_animal()
        elif user_input == "l":
            print_register()
        elif user_input == "e":
            exit_program()
        elif not user_input:
            print("please, enter something!")

Instrucciones:

Crearemos una función para que el usuario vea las opciones de nuestro programa junto a una tecla a presionar para que se ejecute esa opción, y para que el usuario sepa que hacer. Las opciones son: agregar animal, borrar animal, actualizar animal, mirar lista y salir del programa.
Por lo tanto, sería así:

# ~~~~~~~~~~~~~ Functions ~~~~~~~~~~~~~~
def instrucctions():
    print('\nAnimal registry program:'
          '\n1: Enter A or a to add new animal.'
          '\n2: Enter D or d to delete a animal'
          '\n3: Enter U or u to update animal.'
          '\n4: Enter L or l to check list of animals. '
          '\n5: Enter E or e to exit the program.')

Imprimimos las opciones. '/n' significa un salto de linea.

Imprimir registro:

def print_registry():
    x = PrettyTable(["ID", "Scientific Name", "Common Name"])
    for animal_data in animal_dic:
        x.add_row([animal_data, animal_dic[animal_data]["scientific_name"],
                   animal_dic[animal_data]["common_name"]])

    print(x.get_string(title="Animal registry"))

Atento a lo que sucede aquí:

Para darles nombres a los encabezados de las columnas los escribimos en formato de lista, y la pasamos como parámetro de PrettyTable y la almacenamos en la variable "x".
Antes de hablar del ciclo for, debemos recordar y tener muy claro de que estamos intentando acceder a un diccionario dentro de otro diccionario. Solo para tenerlo claro, comparemos un diccionario común, a uno anidado.

Diccionario:

Donde tenemos una colección de elementos almacenados en pares de key/value (clave/valor).

  {'name': 'Adam'}

'name' es la key (clave) y 'Adam' el value (valor).

  {'name': 'Adam', 'last': 'Smith'}

Podemos tener más de un key/value en UN diccionario. 'name' y 'last' son las keys.

Diccionario anidado:

Los valores al exterior del diccionario, también son diccionarios.

  {0: {'book': 'Wealth of Nations', 'author': 'Adam Smith'},
   1: {'book': 'Economic Sophisms',' author': 'Frédéric Bastiat'}}

0 es la key/clave del diccionario externo, y 'book' y 'author' claves del diccionario interno.

Entendido esto, volvamos al código anterior.

for animal_data in animal_dic:

Lo que ocurre aquí es que accedemos al key externo (Es decir, el ID), mediante animal_date.

x.add_row([animal_data, animal_dic[animal_data]["scientific_name"],
           animal_dic[animal_data]["common_name"]])

Ya que accedemos al key externo, tendremos acceso a los valores internos. Ocurre de
la siguiente manera:

animal_dic = ID del animal
animal_dic[animal_data]["scientific_name"] = nombre científico
animal_dic[animal_data]["common_name"] = nombre común

Entonces, pues:

x.add_row([animal_data, animal_dic[animal_data]["scientific_name"],
           animal_dic[animal_data]["common_name"]])

Ingresamos los valores de nuestro diccionario a la fila de PrettyTable como una lista, mediante el
método add_row().

Finalmente le damos un encabezado a nuestra tabla:

print(x.get_string(title="Animal registry"))

Ahora puedes imprimir la lista iniciando el programa y presionando "l" o "L". Obviamente, ahora nuestro diccionario está vacío. Más adelante veremos como ingresarle datos.

Random ID:

Necesitamos un ID para identificar la columna y al animal registrado, este ID servirá como enlace, siendo la key externa de nuestros diccionarios anidados.
Es necesario para un futuro poder actualizar uno o ambos nombres del animal, o borrarlo definitivamente.
Para facilitarle la tarea al usuario, y evitar que cree duplicados, crearemos una función que retorne
un string al azar. Lo haremos con el siguiente código:

def random_id():
    random_string = ''.join(random.choices(string.ascii_uppercase
                                           + string.digits, k=4))
    return random_string

Donde "k" es el largo del string.

La explicación de como funciona esta función está fuera del alcance de este articulo.

Agregar:

Ahora hagamos la función que se encargará de tomar los valores que escriba el usuario e ingresarlos en el diccionario.

def add_animal():
    animal_id = random_id()
    scientific_name = input("\nPlease enter the scientific name: ").title()
    common_name = input("\nPlease enter the common name: ").title()
    data = {animal_id: {'scientific_name': scientific_name,
                        'common_name': common_name}}
    if not scientific_name and not common_name:
        print("You must write something!")
    else:
        animal_dic.update(data)

Lo primero que notarás es que llamamos a la función random_id que devuelve un string y lo almacenamos en la variable animal_id. Como su nombre lo indica, identifica al animal y su fila dentro del registro.
Mediante el método input() le pedimos al usuario que escriba el nombre común y científico. y los almacenamos en variables. Usamos el método .title() por estética.

Hagamos una pausa y miremos otra vez esta parte del código:

    data = {animal_id: {'scientific_name': scientific_name,
                        'common_name': common_name}}

Actualizamos nuestro diccionario anidado y lo almacenamos en una variable llamada "data". De modo que:
animal_id = Es el random ID que retorna nuestra función. Es la key/clave externa de este
diccionario anidado.
'scientific_name': que está entre comillas, es la key/llave interna.
scientific_name: que una variable, es la value/valor interno. Ingresado por el usuario.
El siguiente bloque de código establece una condición donde si el usuario no ingresa
ni un nombre científico ni un nombre común, imprima un mensaje de que debe hacerlo.
Por ultimo, en el 'else': si se han ingresados al menos uno de los dos input()
actualizaremos el "animal_dic" con los datos escritos por el usuario.

Eliminar fila:

Ahora escribamos la función para borrar la fila que el usuario elija, mediante el ID único.

def delete_animal():
    animal_id = input("\nEnter the animal ID you want delete: ").upper()
    if animal_id in animal_dic:
        choice = input("Delete (y/n)").lower()
        if choice == "yes" or choice == "y":
            del animal_dic[animal_id]
            print(f"{animal_id} registry has been deleted!")
    else:
        print("ID not found. Check list pressing 'L'")

Le pedimos al usuario que ingrese el ID de la fila. Usamos upper() para que este no tenga que escribir mayúsculas.
Creamos un 'if': que chequea si el ID ingresado por el usuario está en el diccionario le de la elección de querer borrarlo con un sí o no. Si escribe si se borrara con un "del animal_dic[animal_id]" que busca el ID (key externo) y borra todos sus key/values internos .
Con el else declaramos de que, si no se ha encontrado el ID, imprime un "ID not found"

Actualización:

Tal vez el usuario ha cometido un error de tipeo, y desea cambiar los campos de una fila en especifico
Ahí la necesidad de una función que los actualice.

def update_animal():
    animal_id = input("\nEnter the animal ID you want update: ").upper()
    # If external key in dictionary, if key is equal to ID (animal_id)
    for animal in animal_dic:
        if animal == animal_id:
            choice = input(f"Update registry {animal_id}? (y/n): ").lower()
            if choice == "yes" or choice == "y":
                # Changing names
                scientific_name = input("Write a new scientific name: ").title()
                common_name = input("Write a new common name: ").title()
                if not scientific_name and not common_name:
                    print("You must write something!")
                else:
                # Updating
                    animal_dic[animal]['scientific_name'] = scientific_name
                    animal_dic[animal]['common_name'] = common_name
                    print("registry updated!")
                    print_registry()
        else:
            print("ID not found. Check list pressing 'L'")

El usuario ingresa el ID mediante un input() y es almacenado en una variable.
Sí el ID (key externo) existe en nuestro diccionario avanzará a recorrerlo mediante un for loop, de lo contrario, imprimirá un "ID not found".
Preguntamos si el usuario realmente quiere borrar la fila y almacenamos su respuesta en una variable. Si es afirmativo, procedemos. Contrario se detiene el flujo.
Pedimos al usuario, mediante un input(), que escriba los nuevos nombres y los almacenamos en variables.
Si el usuario ha dejado en blanco ambos campos se imprimirá "You must write something!" de lo contrario accederemos al diccionario, a su llave externa y almacenaremos los nuevos valores.

Salir del programa:

def exit_program():
    sys.exit("Goodbye!")

Usamos el método exit() del modulo built-in sys para salirnos del programa e imprimiremos un
mensaje.

Python Beginners Tutorial: Animal registry

Ricardo Aguilar — Mon, 13 Sep 2021 23:34:27 +0000

We will write a program that will allow us to make a register of animals, with their scientific name and common name, binded by a unique ID. Using that ID we will be able to remove the animal from the register, or simply modify the names already written. Also an option to view the list of animals already registered and an option to exit the program.

The goal is to generate and print a list that can be modified like this:

	Animal Registry
ID	Scientific Name	Common Name
3Y99	Canis Lupus Familiaris	Siberian Husky
MT5R	Cebinae	Capuchin Monkey
8D6U	Octopoda	Octopus
YG0E	Anthophila	Bee
JN14	Dinastinae	Rhinoceros Beetle
WVTA	Python Regius	Ball Python
HAZP	Gorilla	Gorilla

We will work with:

The PrettyTable module.
Nested dictionaries.
Flow control.
Functions.

You must install PrettyTable via Pip.
Try with:
pip install prettytable

First, we will import the necessary modules:
PrettyTable for the creation of the table where we will register the animals, random and string to
generate a random ID with which we will identify the row in the record and sys to exit the program.

from prettytable import PrettyTable
import random
import string
import sys

Now we will create an empty dictionary where we will store the animals that we are going to register.

animal_dic = {}

We will write the conditional "if name == "main"" to avoid import errors and for good practice.
and call our main() function.

if __name__ == "__main__":
    main()

An explanation of how if _name_ == "_main_" works is beyond the scope of this article.

Functions:

Now, let's write the functions that will run our program, these will go BEFORE the conditional "if _name_ == "_main_"" described above. Otherwise Python would try to execute the main() function when it has not been defined, thus triggering an error.

Main function:

Now, we must bind the option chosen by the user to the functions of our program.

The next step is straightforward: inside main() we will force this loop to run, with a while True,
it will print the instructions to add, delete, update, check and exit the program.
We also have an input() that will be the option that the user chooses and this will be stored in
the variable user_input. Pay attention to the .lower() method, transform what the user enters into lower case, so we avoid typing errors.
Finally, the conditionals. Depending on what the user chooses, a function will be called.

# ~~~~~~~~~~~~~~~~~~ Functions(): ~~~~~~~~~~~~~~~~~~~
def main():
    # ~~~~~~~~~~~~~~ User's choise ~~~~~~~~~~~~~~~
    while True:
        instrucctions()
        user_input = input("\nWhat do you want to do? "
                           "(a, d, u, l, e): ").lower()
        if user_input == "a":
            add_animal()
        elif user_input == "d":
            delete_animal()
        elif user_input == "u":
            update_animal()
        elif user_input == "l":
            print_register()
        elif user_input == "e":
            exit_program()
        elif not user_input:
            print("please, enter something!")

Instructions:

We will create a function so that the user can see the options of our program along with a key to press to execute that option, and so that the user knows what to do. The options are: add animal, delete animal, update animal, check list and exit the program.
So, it would be like this:

# ~~~~~~~~~~~~~ Functions ~~~~~~~~~~~~~~
def instrucctions():
    print('\nAnimal registry program:'
          '\n1: Enter A or a to add new animal.'
          '\n2: Enter D or d to delete a animal'
          '\n3: Enter U or u to update animal.'
          '\n4: Enter L or l to check list of animals. '
          '\n5: Enter E or e to exit the program.')

We print the options. '/n' means a line break.

Print the list:

def print_registry():
    x = PrettyTable(["ID", "Scientific Name", "Common Name"])
    for animal_data in animal_dic:
        x.add_row([animal_data, animal_dic[animal_data]["scientific_name"],
                   animal_dic[animal_data]["common_name"]])

    print(x.get_string(title="Animal registry"))

Pay attention to what happens here:

To give names to the column headers we write them in list format, and we pass it as parameter of PrettyTable and store it in the variable "x".
Before we talk about the for cycle, we must remember and be aware that we are trying to access a dictionary *within a dictionary. Just to lining things up, let's compare a common* dictionary, to a nested one.

Dictionary:

Where we have a collection of items stored in key/value pairs.

  {'name': 'Adam'}

'name' is the key and 'Adam' is the value.

  {'name': 'Adam', 'last': 'Smith'}

We can have more than one pair of key/value in just ONE dictionary. 'name' and 'last' are both keys.

Nested dictionary:

The values to the outside of the dictionary, are also dictionaries.

  {0: {'book': 'Wealth of Nations', 'author': 'Adam Smith'},
   1: {'book': 'Economic Sophisms',' author': 'Frédéric Bastiat'}}

0 is the key of the external dictionary, and 'book' and 'author are keys of the internal dictionary.

With that in mind, let's go back to the previous code.

for animal_data in animal_dic:

What happens here is that we access the external key, through animal_data.

x.add_row([animal_data, animal_dic[animal_data]["scientific_name"],
           animal_dic[animal_data]["common_name"]])

Since we access the external key, we will have access to the internal values. It happens as follows:

animal_dic = Animal ID
animal_dic[animal_data]["scientific_name"] = scientific name
animal_dic[animal_data]["common_name"] = common name

So, then:

x.add_row([animal_data, animal_dic[animal_data]["scientific_name"],
           animal_dic[animal_data]["common_name"]])

We enter the values of our dictionary into the row of PrettyTable as a list, by means of the
method add_row(). Look carefully, everything is between braces [].

Finally we give a header to our table:

print(x.get_string(title="Animal registry"))

Now you can print the list by starting the program and pressing "l" or "L". Obviously, in this moment our dictionary is empty. We will see later how to enter data into it.

Random ID:

We need an ID to identify our rows, this ID will serve as a binding, being the external key of our nested dictionaries.
It is necessary, in the future, to be able to update one or both names of the animal, or to delete it definitively.
To make it easier for the user, and to avoid creating duplicates, we will create a function that returns
a random string. We will do it with the following code:

def random_id():
    random_string = ''.join(random.choices(string.ascii_uppercase
                                           + string.digits, k=4))
    return random_string

Where "k" is the length of the string.

An explanation of how this function works is beyond the scope of this article.

Add:

Now let's make the function that will take the values typed by the user and enter them into the dictionary.

def add_animal():
    animal_id = random_id()
    scientific_name = input("\nPlease enter the scientific name: ").title()
    common_name = input("\nPlease enter the common name: ").title()
    data = {animal_id: {'scientific_name': scientific_name,
                        'common_name': common_name}}
    if not scientific_name and not common_name:
        print("You must write something!")
    else:
        animal_dic.update(data)

The first thing you'll notice is that we call the random_id function which returns a string and store it in the animal_id variable. As the name implies, it identifies the animal and the row within the record.
Using the input() method we ask the user to type the common and scientific name. and store them in variables. We use the .title() method for aesthetics.

Let's pause and look at this part of the code again:

    data = {animal_id: {'scientific_name': scientific_name,
                        'common_name': common_name}}

We update our nested dictionary and store it in a variable called "data". So:
animal_id is the random ID that our function returns. It is the external key of this
nested dictionary.
'scientific_name': which is in quotation marks, is the internal key.
scientific_name: which is a variable, is the internal value. Entered by the user.
The next block of code sets a condition where if the user does not enter either a scientific name or a common name, print a message that he/she must do so.
Finally, in the 'else': if at least one of the two input() have been entered, we will update the "animal_dic" with the data entered by the user.

Delete row:

Now let's write the function to delete the row of the user's choice, using the unique ID.

def delete_animal():
    animal_id = input("\nEnter the animal ID you want delete: ").upper()
    if animal_id in animal_dic:
        choice = input("Delete (y/n)").lower()
        if choice == "yes" or choice == "y":
            del animal_dic[animal_id]
            print(f"{animal_id} registry has been deleted!")
    else:
        print("ID not found. Check list pressing 'L'")

We ask the user to enter the ID of the row. We use the * upper () * method so that the user does not have to type in all capital letters.
We create an 'if' that checks if the ID entered by the user is in the dictionary, then give him the choice to delete it with a yes or no. If user types yes it will be deleted with a "del animal_dic[animal_id]" which looks for the ID (external key) and deletes all its internal key/values.
With the else we declare that, if the ID has not been found, it prints "ID not found"

Update:

Perhaps the user has made a typo, and wants to change the fields in a specific row.
There is a need for a function to update them.

def update_animal():
    animal_id = input("\nEnter the animal ID you want update: ").upper()
    # If external key in dictionary, if key is equal to ID (animal_id)
    for animal in animal_dic:
        if animal == animal_id:
            choice = input(f"Update registry {animal_id}? (y/n): ").lower()
            if choice == "yes" or choice == "y":
                # Changing names
                scientific_name = input("Write a new scientific name: ").title()
                common_name = input("Write a new common name: ").title()
                if not scientific_name and not common_name:
                    print("You must write something!")
                else:
                # Updating
                    animal_dic[animal]['scientific_name'] = scientific_name
                    animal_dic[animal]['common_name'] = common_name
                    print("registry updated!")
                    print_registry()
        else:
            print("ID not found. Check list pressing 'L'")

The user enters the ID via an input() and it is stored in a variable.
If the ID (external key) exists in our dictionary it will step through it with a for loop, otherwise, it will print an "ID not found".
We ask if the user really wants to delete the row and store their answer in a *variable. If yes, we proceed. Otherwise the flow stops.
We ask the user, using an input(), to type the new names and we store them in variables.
If the user has left both fields blank, it will print "You must write something!" otherwise we will access the dictionary, its foreign key and store the new values.

Exit the program:

def exit_program():
    sys.exit("Goodbye!")

We use the exit() method of the built-in sys module to exit the program and print a message.

Full code:

https://github.com/RicardoRien/animal_registry