jueves, 22 de diciembre de 2016

VALIDAR USUARIO Y CONTRASEÑA EN PYTHON (2 FORMA: CLASES)

Hola esta es otra forma de realizar el ejercicio utilizando clases y gracias al usuario Sergabrod, quien colaboró para realizar el ejercicio de otra forma. Volveré a poner los enunciados.

También puedes ver la primera solución acá (1ra forma)

Este ejercicio lo tomé de la página: http://librosweb.es/libro/python/capitulo_6/ejercicios.html

1. MÓDULO USUARIO.(usuario)

Crear un módulo para validación de nombres de usuarios. Dicho módulo, deberá cumplir con los siguientes criterios de aceptación:

1.1 El nombre de usuario debe contener un mínimo de 6 caracteres y un máximo de 12.
1.2 El nombre de usuario debe ser alfanumérico.
1.3 Nombre de usuario con menos de 6 caracteres, retorna el mensaje "El nombre de usuario debe       contener al menos 6 caracteres".
1.4 Nombre de usuario con más de 12 caracteres, retorna el mensaje "El nombre de usuario no puede contener más de 12 caracteres".
1.5 Nombre de usuario con caracteres distintos a los alfanuméricos, retorna el mensaje "El nombre de usuario puede contener solo letras y números".
1.6 Nombre de usuario válido, retorna True.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class usuario_validar():
    
    errors=[]
    
    def longitud(self,username):
        if len(username)<6:
            self.errors.append('El nombre de usuario debe contener al menos 6 caracteres')
            return False

        elif len(username)>12:
            self.errors.append('El nombre de usuario debe contener maximo 12 caracteres')
            return False

        else:
            return True
    
    def alfanumerico(self,username):
        if username.isalnum()==False:
            self.errors.append('El nombre de usuario puede contener solo letras y numeros')
            return False
        else:
            return True

    def validar_usuario(self,username):
        valido=self.longitud(username) and self.alfanumerico(username)
        return valido

2. MÓDULO PASSWORD.(password)
Crear un módulo para validación de contraseñas. Dicho módulo, deberá cumplir con los siguientes criterios de aceptación:
2.1 La contraseña debe contener un mínimo de 8 caracteres.
2.2 Una contraseña debe contener letras minúsculas, mayúsculas, números y al menos 1 carácter no alfanumérico.
2.3 La contraseña no puede contener espacios en blanco.
2.4 Contraseña válida, retorna True.
2.5 Contraseña no válida, retorna el mensaje "La contraseña elegida no es segura".


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class password_validar():

    errors=[]

    def longitud(self, passw):
        if len(passw) < 8:
            self.errors.append('La contrasena debe tener al menos 8 caracteres')
            return False
        else:
            return True

    def minuscula(self, passw):
        letras_minuscula=False
        for carac in passw:
            if carac.islower()==True:
                letras_minuscula=True
        if not letras_minuscula:
            self.errors.append('La contrasena debe tener al menos una minuscula')
            return False
        else:
            return True

    def mayuscula(self, passw):
        letras_mayuscula=False
        for carac in passw:
            if carac.isupper()==True:
                letras_mayuscula=True
        if not letras_mayuscula:
            self.errors.append('La contrasena debe tener al menos una mayuscula')
            return False
        else:
            return True

    def numero(self, passw):
        num=False
        for carac in passw:
            if carac.isdigit()== True:
                num=True

        if not num:
            self.errors.append('La contrasena debe tener al menos un numero')
            return False
        else:
            return True

    def no_alfanumerico(self, passw):
        if passw.isalnum()==True:
            self.errors.append('La contrasena debe tener al menos un caracter no alfanumerico')
            return False
        else:
            return True

    def espacios(self, passw):
        if passw.count(" ")> 0:
            self.errors.append('La contrasena no puede contener espacios en blanco')
            return False
        else:
            return True

    def validar_password(self,passw):
        valido=self.longitud(passw) and self.minuscula(passw) and self.mayuscula(passw) and self.numero(passw) and self.no_alfanumerico(passw) and self.espacios(passw)
        return valido

3. MÓDULO VALIDADOR.(login)

Crear un módulo que solicite al usuario el ingreso de un nombre de usuario y contraseña y que los valide utilizando los módulos generados en los dos ejercicios anteriores. Solución módulo validador.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# -*- coding: utf-8 -*-

import usuario  as uv
import password as pv

user_validator = uv.usuario_validar()
pass_validator = pv.password_validar()

correcto= False

while correcto==False:
    nombre = raw_input('Ingrese su nombre de usuario: ')
    if not user_validator.validar_usuario(nombre):
        for error in user_validator.errors:
            print error
            correcto=False
            user_validator.errors.remove(error)           
    else:
        correcto=True
            
while correcto==True:        
    passwd = raw_input('Ingrese su contraseña: ')
    if not pass_validator.validar_password(passwd):
        for error in pass_validator.errors:
            print error
            correcto=True
            pass_validator.errors.remove(error)
    else:
        correcto=False

Video prueba:


Si tienen alguna duda con gusto la puedo aclarar.