# Ejemplo. Cálculo de Nómina mensual

Diseñar un programa que permita a la empresa XX calcular la nómina mensual de sus trabajadores por horas. El salario del trabajador estará en función de las horas trabajadas (no podrá realizar más de 8 horas diarios) y su categoría. El coste por hora es de 15 Euros para los trabajadores cuya categoría sea A, 10 si es de categoría B. Se realizará un registro diario. Un trabajador puede realizar un trabajo dentro de la categoría A o B.

En primer lugar, se construirá una tupla con todos los trabajadores que tiene la empresa.

Para ello, tendrá un menú que permita:

1. Introducir los datos diarios de los trabajadores. Se debe preguntar cuántos trabajadores va a introducir en el programa principal. Para ello, se creará una función llamada Nuevo\_trabajo, y devuelve la lista creada (Nombre del trabajador, número de horas, y categoría). Esta opción se implementará por pantalla y archivo
2. Indicar cuantos trabajadores hicieron un trabajo perteneciente a una categoría (A o B), esté dato se le preguntará al usuario en el programa principal. Para ello, crear una función Contabilizar\_categoría y la función devuelve la cantidad calculada que se visualizará en programa principal.
3. Indicar cuantos trabajadores no realizaron ningún trabajo y su nombre, utilizar conjuntos. Para ello, utilizará una función Llamada Trabajadores\_sin\_sueldo y debe devolver una cadena con los nombre y la cantidad, que será visualizada en el programa principal.
4. Calcular **el desembolso que realizará la empresa.** Para ello, creará una función llamada Cálculo\_nómina, que me devuelva la cantidad a pagar por la empresa, esta información se visualizará en el programa principal.
5. Salir.

## Análisis

![](https://156834076-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-M3CsDMenpAVuNy6kou5%2F-MZb3FbVu1_5EkldOg4M%2F-MZb5gCA24sPJhnOE5JB%2Fbuen_diagrama.jpg?alt=media\&token=234c19f1-5cd6-4b15-974d-fb51b438ac56)

## Diagrama

![](https://156834076-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-M3CsDMenpAVuNy6kou5%2F-M7JD83S7oBNyQmZ1MDd%2F-M7JDIo6mIPei0ODE5q0%2Fmatriz_5.jpg?alt=media\&token=a4d1cc1a-0409-40c0-bcc2-556f24151bbf)

## Archivo Nómina

{% file src="https://156834076-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-M3CsDMenpAVuNy6kou5%2F-M6j4MvKokh6TGbSa1aB%2F-M6jA_rHRj9gLPi7CA4H%2Fnomina.txt?alt=media&token=d4c15dd0-fa85-4ca6-a9c5-867c4ab03278" %}

## Código programa principal.&#x20;

La función `def menu(`) visualiza las opciones, `def pedir_datos(mensaje,limite)`, permite de validar las diferentes opciones del menú y para validar el número de horas.

```
def menu():
    print(
        '''
        CÁLCULO DE NÓMINA MENSUAL
        
        1 - Introducir horas trabajadas
        2 - Contabilizar categoría
        3 - Trabajadores sin sueldo
        4 - Cálculo de nóminas
        
        S - Salir
        '''
        )
def pedir_datos(mensaje, limite):
    cierto=True
    while cierto:
        try:
              numero=int(input(mensaje))
              if numero >=0 and numero<=limite:        
                   cierto=False
   #                print("Has introducido un número correcto")
              else:
                   print("Haste tecleado un número fuera del límite")
        except:
                print("Has introducido una letra")
        return numero   
tupla=("IRIA","JUAN","DANIEL","ANA","SERGIO","LUIS")
categoria=[["A", 10],["B",15]]
nomina=[["IRIA","A",5],["JUAN","B",5],["JUAN","A",5]]
bandera=True
while bandera:
    menu()
    opcion=pedir_datos("dame la opción a realizar",5)
    if opcion==1:
        print("opcion trabajadores")
        
            
    elif opcion==2:
            print("Contabilizar categoríar")
           
    elif opcion==3:
            print("Trabajadores sin sueldo")
            
    elif opcion==4:
            print("Nómina")
    elif opcion ==5:
            print("fin")
            bandera=False
    else:
            print("Cálculo de nóminas")
print("fin de programa")

menu()

```

{% hint style="info" %}
OJO `nomina=[["IRIA","A",5],["JUAN","B",5],["JUAN","A",5]]` es para poder poder probar las opciones 2,3. Pero no se sabe cuantos datos tendra debe ser `nomina=[]`
{% endhint %}

## Elementos comunes

Se pregunta en la opción 1 y opción 2 la categoría, con lo cuál se debe validar y crear una sola función que lo permita en este caso se llama `pedir_categoria (categoria_precio).`

```
def pedir_categoria (categoria_precio):
    cierta=True
    while cierta:
         categoria=input("Introduce la categoria A o B").upper()
         print(categoria_precio[0][0]," ", categoria_precio[1][0])
         if categoria !=categoria_precio[0][0] and categoria!=categoria_precio[1][0]:
                  print("Debes introducir o A o B")
         else:
             cierta=False
```

## Opción 1. Introducir los datos diarios de los trabajadores por teclado

`pedir_datos(nominamcantidad,tupla,categoria_precio)`, permite introducir los datos diarios de los trabajadores y `verificar_nombre(nomina,nombre)`, verifica que ese trabajador no exceda las 8 horas.

```
def verificar_nombre(nomina,nombre):
    total=0
   
    trabajadores_existe=set([]) #creo otro conjunto
    for i in nomina: #recorro la matriz
        print("i",i)
        trabajadores_existe.add(i[0])
    if nombre in trabajadores_existe:
         for i in nomina:
            print(i[1])
            if i[0]==nombre:
                total+=i[2]
            
    return total
 
def pedir_datos(nomina,cantidad,tupla,categoria_precio):
    for i in range(cantidad+1):
        
        condicion=True
       
        while condicion:
            nombre=input("dame el nombre del trabajador").upper()
            if nombre in tupla:
                total=0
                horas=verificar_datos("Dame la cantidad de horas que trabajo", 8)
                categoria=pedir_categoria (categoria_precio)
                if i!=0:
                    total=verificar_nombre(nomina,nombre)
                if total + horas >8:
                        print("Te has excedido en el número de horas")
                else:    
                   nomina.append([])
                   nomina[i].append(nombre)
                   nomina[i].append(categoria)
                   nomina[i].append(horas)
                  
                   condicion=False
            
    return nomina
```

## Opción1. Obtiene los datos de un archivo.

```
import os
    
def introducir_datos_archivo(matriz):
        cierta=True
        while cierta:
            nombre_del_archivo=input("dame el nombre del archivo")
#            nombre_del_archivo="nomina.txt", es el nombre del archivo que aparece arriba
            if os.path.exists(nombre_del_archivo):
                i=0
                archivo=open(nombre_del_archivo,"r")
                for lineas in archivo.readlines():
                    print(lineas)
                    
                    matriz.append([])
                    informacion=lineas.split(";")
                    for j in range(3):
                            matriz[i].append(informacion[j])            
                    i+=1
                print(matriz)            
                archivo.close()
                return matriz
    
            else:
                print("El archivo no existe")
                        
```

{% hint style="info" %}
El archivo nomina.txt está al principio
{% endhint %}

## Opción 1. Programa principal

```
    if opcion==1:
        print("opcion trabajadores")
       
        pedir_datos(nomina,cantidad,tupla,categoria_precio)
```

## Opción 2. Indicar cuantos trabajadores hicieron un trabajo perteneciente a una categoría (A o B)&#x20;

### Funcion con listas

```
def Contabilizar_categoria(nomina, categoria):
    
    trabajadores=0
    for i in (nomina):
        print(i)
        if categoria==i[1]:
            trabajadores+=1
    return trabajadores 
```

### Función con numpy

```
def Contabilizar_categoria(nomina,categoria):#creo la funcion 2
    contador_categoria=0
    #recorro mis columnas nomina.shape[0]
    print(nomina.shape[1])
    for i in range (nomina.shape[1]):
         if categoria ==nomina[i][1]:
             #sumo el numero de trabajadores de la categoria que introdujo el usuario 
             contador_categoria+= 1
            
    #devuelvo el valor a la funcion
    return contador_categoria 
```

{% hint style="info" %}
Ojo que le factaría a la Opción 2. Con listas o numpy
{% endhint %}

### Programa principal. Opción 2

```
elif opcion==2:
            print("Contabilizar categoríar")
            cierto=True
            while cierta:
                categoria=input("Introduce la categoria A o B").upper()
                print(categoria_precio[0][1])
                if categoria ==categoria_precio[0][0] or categoria==categoria_precio[0][1]:
                    cuenta=Contabilizar_categoria(nomina,categoria) #llamo la segunda funcion
                    print("Hay {0} trabajadores de la categoria {1}".format(cuenta,categoria))
                    cierta=False
                else:
                    print("Debes introducir o A o B")
```

### Puntualizaciones

La opción 1 y la opción 2, le preguntan al usuario cuál es la categoría y validan. Con lo cuál, lo más conveniente, es crear una función que permita validar la  categoria, en este caso se llamará `def pedir_categoria (categoria_precio).`

### Programa principal. Opción 2

```
print("Contabilizar categoría")
            if len(nomina)!= 0:
                categoria=pedir_categoria (categoria_precio)
                cuenta=Contabilizar_categoria(nomina,categoria) #llamo la segunda funcion
                print("Hay {0} trabajadores de la categoria {1}".format(cuenta,categoria))
                cierta=False
            else:
                print("Nadie realizo ningún trabajo")
```



### Opción 3. Indicar cuantos trabajadores no realizaron ningún trabajo y su nombre

La función `def visualizar_conjunto(Trabajadores_sintrabajo)`, se utiliza para imprimir el valor del conjunto

```
def visualizar_conjunto(Trabajadores_sintrabajo):
    trabajador=""
    for i in Trabajadores_sintrabajo:
        trabajador+=i+" "
    return trabajador
def Trabajadores_sin_sueldo(nomina,tupla): #creo la funcion 3
    trabajadores_todos=set(tupla) #creo un conjunto
    trabajadores_contrabajo=set([]) #creo otro conjunto
    for i in nomina: #recorro la matriz
        print(i)
        trabajadores_contrabajo.add(i[0]) #añado cada nombre de todos los trabajadores de la matriz al primer conjunto
    print(trabajadores_contrabajo)
    Trabajadores_sintrabajo=trabajadores_todos-trabajadores_contrabajo #solo guardo los trabajadores que no estan en la matriz
    print(Trabajadores_sintrabajo)
    if len(Trabajadores_sintrabajo)==0:
        enviar="Todos lo trabajadores han realizado algún trabajo"
    else:
        enviar="Los trabajadores han realizado algún trabajo son: "+ visualizar_conjunto(Trabajadores_sintrabajo) +" y son "+ str(len(Trabajadores_sintrabajo))
       
    return enviar
```

### Programa Principal. Opción 3

```
    elif opcion==3:
            print("Trabajadores sin sueldo")
            if len(nomina)!= 0:
                print(Trabajadores_sin_sueldo(nomina,tupla))
            else:
                print("Nadie realizo ningún trabajo")
```

## Opción 4. Desembolso de la empresa. Nómina

```
def calculo_nomina(nomina,categoria):
    total=0
    for i in nomina:
        print(i[1])
        if i[1]==categoria[0][0]:
            precio=categoria[0][1]
        else:
            precio=categoria[1][1]
        total+=precio*int(i[2])
    return total
```

### Programa Principal. Opción 3

```
elif opcion==4:
            print("Nómina")
            if len(nomina)!= 0:
                print("la nómina es de: ", calculo_nomina(nomina,categoria_precio))
            else:
                print("Nadie realizo ningún trabajo")
```
