No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

Proyecto: generador de contraseñas

31/32
Recursos

En este ejemplo, veremos cómo crear un generador de contraseñas en Python:

Generador de contraseñas

import random
import string

def generar_contrasena():
    caracter = string.ascii_lowercase + string.digits + string.punctuation + string.ascii_uppercase

    contrasena = []

    while (len(contrasena) < 16):
        caracteres=random.choice(caracter)    
        contrasena.append(caracteres)

    contrasena = "".join(contrasena)
    return contrasena

def run():
    contrasena = generar_contrasena()
    print('Tu nueva contraseña es: '+ contrasena)

if __name__ == "__main__":
    run()

Aporte creado por: Brahian Caro

Aportes 424

Preguntas 79

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Acá pueden tener las listas de todos los caracteres:

MAYUS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
MINUS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
NUMS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
CHARS = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']

Recomiendo esta pagina para practicar con ejercicios: https://www.codewars.com/dashboard

import random
import string

def generar_contrasena():
    caracter = string.ascii_lowercase + string.digits + string.punctuation + string.ascii_uppercase

    contrasena = []

    while (len(contrasena) < 16):
        caracteres=random.choice(caracter)    
        contrasena.append(caracteres)

    contrasena = "".join(contrasena)
    return contrasena

def run():
    contrasena = generar_contrasena()
    print('Tu nueva contraseña es: '+ contrasena)

if __name__ == "__main__":
    run()

para practicar todos los conceptos aprendidos hice el juego del ahorcado (Adivinando palabras).

Otra manera de obtener la lista de letras desde un string, ya que se vuelve engorroso hacer la lista de cada letra separada por comas, puede ser la siguiente:

upper_case = 'A B C D E F G H I J K L M N O P Q R S T U V W X Y Z'
upper_case = upper_case.split()

Que retorna la siguiente cadena: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

La función choice(secuencia) elige un valor al azar en un conjunto de elementos. Cualquier tipo de datos enumerable (tupla, lista, cadena, range) puede utilizarse como conjunto de elementos.
La función join convierte una lista en una cadena formada por los elementos de la lista separados por comas.

no sería mejor que todas las listas fueran tuplas excepto la de “contraseña”?

hay una libreria que viene con python llamada string la cual trae todas las letras caracteres y demas signos

Profe: "Este es nuestro último archivo del curso"
Todos: ༼ つ ◕_◕ ༽つ

Definitivamente aprender con instructores que le ponen el alma a la enseñanza es un privilegio. Que fácil que hace ver las cosas. Gracias infinitas Facundo

Hice mi propia versión con un par de reglas que creo importantes.

  • Se puede especificar el largo de la contraseña.
  • El primer y último carácter siempre van a ser una letra.

Excluyendo al primero y último las probabilidades para elegir cada carácter son las siguientes:

  • Letra mayúscula: 30%
  • Letra minúscula: 30%
  • Número: 20%
  • Símbolo: 20%
import random
import string

def generar_contrasena(cant):
    contrasena = ""
    vueltas = 0
    while vueltas != cant:
        if vueltas == 0 or vueltas == cant - 1:
            contrasena += random.choice(string.ascii_letters)
        else:
            caracter = random.randint(1, 5)
            if caracter == 1:
                contrasena += random.choice(string.punctuation)
            elif caracter == 5:
                contrasena += random.choice(string.digits)
            else:
                contrasena += random.choice(string.ascii_letters)
        vueltas += 1

    return contrasena


def run():
    numero_caracteres = 18
    contrasena = generar_contrasena(numero_caracteres)
    print("Tu contraseña es: " + contrasena)


if __name__ == "__main__":
    run()

Quieres practicar jugando?

https://www.codingame.com/home

Super recomendado!!

Les dejo esta página de internet que evalúa la seguridad de tus contraseñas:
https://howsecureismypassword.net/

me tome unos minutos en escribir todas las letras en mayúsculas, luego como aun faltaban las minúsculas opté por cambiar la lista que ya tenia en una nueva lista, lo hice con un ciclo, quizas no sea lo mas optimo pero me sirvio para practicar como cambiar los strings y me tomo menos tiempo que escribir todas las letras nuevamente 😄

def generate_password():
    capitals = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
                'J','K','L','M','N','O','P','Q',
                'R','S','T','U', 'V','W', 'X','Y','Z'
                 ]
    
    lowercase= ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
                'J','K','L','M','N','O','P','Q',
                'R','S','T','U', 'V','W', 'X','Y','Z'
                 ]
    for i in range (len(lowercase)):
        lowercase[i]= lowercase[i].lower()```

Usando la libreria string es inecesario crear listas, solo se suman los metodos para extraer letras, numeros y simbolos de la libreria string :p

import random
import string

def generate_password():
    # capitalize = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','Y','X','Y','Z']
    # lowercase = [letter.lower() for letter in capitalize] 
    # symbols = ['?','¡','¿','%','&','$','#','/','!','+','[']
    # numbers = ['1','2','3','4','5','6','7','8','9','10']

    # characters = capitalize + lowercase + symbols + numbers

    characters = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation

    password = []

    for i in range(15):
        character_random = random.choice(characters)
        password.append(character_random)

    password = "".join(password)

    return password



def run ():
    password = generate_password()
    print('Your new password is: ' + password)

if __name__ == '__main__':
    run()

Generador de id unico aleatorio con tu datos personales

import random


def generador_id():
    #Generamos datos de entrada para el id aleatorio
    cedula = int(input("Dijita la cedula: "))
    apellido = input("Dijita la Apellido: ")
    nombre = input("Dijita el nombre: ")
    nacionalidad = input("Dijita tu nacionalidad: ")
    fecha_entrada = int(input("Dijista tu fecha entrada MM/DD/AA :"))
    numero_aleatorio = random.randint(1000,9999)

    # Convertimos las variables enteras a string
    cedula = str(cedula)
    fecha_entrada = str(fecha_entrada)
    numero_aleatorio = str(numero_aleatorio)

    #Reducimos los string a sus primero 4 caracteres
    nombre = nombre[:3]
    apellido = apellido[:3]
    nacionalidad = nacionalidad[:3]
    cedula = cedula[:3]    
    fecha_entrada = fecha_entrada[:3]
    

    #Convierto esos 4 caracteres en una lista
    lista_cedula = list(cedula)
    lista_nombre = list(nombre)
    lista_apellido = list(apellido)
    lista_nacionalidad = list(nacionalidad)
    lista_fecha_entrada = list(fecha_entrada)
    lista_numero_aleatorio = list(numero_aleatorio)

    #concatenacion de las listas
    combinacion = lista_nombre + lista_apellido + lista_nacionalidad + lista_cedula + lista_fecha_entrada + lista_numero_aleatorio
    # lista mutable que contendra nuestro id unico (coparen con un contador si quieren entender)
    id_unico = []

    # ciclo que se itera 15 veces escogiendo 1 caracter a la ves y agregandolo a id_unico
    for i in range(15):
        id_random = random.choice(combinacion)
        id_unico.append(id_random)
    #convertimos la lista en un string
    id_unico = "".join(id_unico)
    #regresamos el valor string a la funcion generador_id()
    return id_unico


def run():    
    id_unico = generador_id()
    print ("Tu id unico es: "+ id_unico+"")


if __name__ == "__main__":
    run()```

Versión 1:

import random


def create_password():
    new_password = ""
    letters = '[email protected]#$/()-1234567890'

    for i in range(16):
        new_password += random.choice(letters)

    return new_password


def run():
    password = create_password()
    print(" You new password is: " + password)


if __name__ == "__main__":
    run()

Versión 2:

import random
import string


def create_password(number):
    new_password = ""
    letters = string.ascii_uppercase + string.ascii_lowercase + \
        string.digits + string.punctuation

    for i in range(number):
        new_password += random.choice(letters)

    return new_password


def run():
    number = int(input("Maximum characters : "))
    password = create_password(number)
    print(" You new password is: " + password)


if __name__ == "__main__":
    run()

Aquí dejo como aporte las listas completas para una mayor seguridad 🧐

mayusculas = ['A', 'B' , 'C', 'D', 'E', 'F' , 'G' , 'H', 'I', 'J', 'K', 'L' , 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    minusculas = ['a', 'b' , 'c', 'd', 'e', 'f' , 'g' , 'h', 'i', 'j', 'k', 'l' , 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
    simbolos = ['!', '#' , '$', '&', '/', '(' , ')' , '?', '¡', '¿', '!']```
import random

def generar():
    #declaracion de listas
    mayus = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
    minus = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    numeros = ['0','1','2','3','4','5','6', '7', '8', '9']

    #declaracion de variables
    caracteres = mayus + minus + numeros
    contrasena = []
    contador = 0

    #ciclo para generar contrasenas
    while contador < 15:
        caracter = random.choice(caracteres)
        contrasena.append(caracter)
        contador += 1

    #conversion de lista a cadena de texto
    contrasena = "".join(contrasena)

    return contrasena


def run():
    contrasena = generar()
    print('Tu nueva contrasena es: ' + contrasena)


if __name__ == '__main__':
    run()

Hola al escribir todo el código me sale que la variable i está sin uso:

for i in range(15):
    caracter_random = random.choice(caracteres)
    contrasena.append(caracter_random)

_Pylint(unused-variable) [14,9]

cambié la i por _ por si alguien le sirve y pylint lo ignoró.

import random

def generar_contrasena():
    mayusculas = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','W','X','Y','Z']
    minusculas = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','w','x','y','z']
    simbolos = ['!','#','$','&','/','(',')','@','¡','?','+']
    numeros = ['1','2','3','4','5','6','7','8','9','0']

    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range(15):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)
    
    contrasena = "".join(contrasena)
    return contrasena

    
def run():
    contrasena = generar_contrasena()
    print("Tu nueva contraseña es: " + contrasena)


if __name__ == '__main__':
    run()```

Reuniendo algunos aportes, no es necesario convertir strings en listas random.choice funciona en strings, existe random.choices(iterable,k=n) que entrega una lista aleatoria al tomar como argumento el string y reemplazando n con la cantidad de lementos deseados.
.
De ser necesario es más rápido usar:

letras = 'qwerttyuiopasdfghjklñzxcvbnm'
list(letras) //devuelve la lista de caracteres del string haciendo más fácil el proceso
list(letras.upper())

Al importar string se pueden obtener diferentes caractereres:

import string
chars = string.ascii_letters + string.punctuation + string.digits
#>>>print(chars)
#>>>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>[email protected][\\]^_`{|}~0123456789'
import random

def generar_contrasena(n):
   
    chars = ''.join( map(lambda x: chr(x), range(32,127)) ) #Usa la tabla ASCII desde el 32(espacio) al 126 (~)
#>>>print(chars)
#>>>' !"#$%&\'()*+,-./0123456789:;<=>[email protected][\\]^_`abcdefghijklmnopqrstuvwxyz{|}~'
    random_chars = random.choices(chars,k=n) #Crea una lista aleatoria de n elementos de chars
    password = ''.join(random_chars)
    return password


def run():
    cantidad = int(input('¿Cantidad de caracteres?: '))
    random_password = generar_contrasena(cantidad)
    print(f'Tu nueva contraseña es: {random_password}')
    

if __name__ == '__main__':
    run()
password = ''.join( map(lambda x: chr(x), range(32,127)) ) 
#es equivalente a:
password = ''
for x in range (32,127):
    password += chr(x)
#sin tener que inicializar password

import random
import string

def create_password():
    letters = list(string.ascii_letters) # List of letters A-Z and a-z
    numbers = list(string.digits) # List of digits 0-9
    symbols = list(string.punctuation) # List of special characters

    characters = letters + numbers + symbols

    password = ""
    for i in range(15):
        password += random.choice(characters)

    return password


def run():
    password = create_password()
    print('Tu nueva contraseña es: ' + password)


if __name__ == '__main__':
    run()
 

Codigo con la posibilidad de escoger la cantidad de caracteres

import random
import string


def password_gen(cantidad_caracteres):
    letter_lowercase = list(string.ascii_lowercase)
    letter_uppercase = list(string.ascii_uppercase)
    numbers = list(string.digits)
    caracters = list(string.punctuation)
    caracters_list = letter_lowercase + letter_uppercase + numbers + caracters
    password=[]
    for i in range(cantidad_caracteres):
        caracter_randown = random.choice(caracters_list)
        password.append(caracter_randown)
    password = ''.join(password)
    return password


def run():
    cantidad_caracteres = int(input('Digíte un número entero para determinar la cantidad de caracteres: '))
    password = password_gen(cantidad_caracteres)
    print(f'Su contraseña es: {password}')


if __name__ == "__main__":
    run()

Se conecta con un diccionario de manera remota y el resto lo toma de la tabla ascii

import urllib.request
import random
con = []


def palabra(num):
    url = "http://svnweb.freebsd.org/csrg/share/dict/words?view=co&content-type=text/plain"
    res = urllib.request.urlopen(url)
    long = res.read().decode()
    list = long.splitlines()
    word = [i for i in list if len(i) <= num]
    return random.choice(word)


def contraseña(num):
    con.append(palabra(num))
    while sum(len(i) for i in con) < num:
        con.append(chr(random.randint(48, 122)))
    print(''.join(con))


if __name__ == '__main__':
    num = int(input('Cuantos caracteres quieres: '))
    contraseña(num)

🔐 Complementando letras y caracteres para tener una contraseña menos vulnerable.

import random


def generar_contrasena():
    mayusculas = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
    minusculas = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
    simbolos = ["!", "#", "€",  "$", "&", "?", "¿", "/", "(", ")"]
    numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]

    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range(8):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)

    contrasena = "".join(contrasena)
    return contrasena


def run():
    contrasena = generar_contrasena()
    print("Tu nueva contraseña es: " + contrasena)


if __name__ == "__main__":
    run()

Wow, no esperaba poder hacer este tipo de cosas en python en tan poco tiempo c:

Les dejo la documentación de Python en cuestión de Strings
https://docs.python.org/3/library/string.html

En el ciclo for no utiliza i en ningun momento

 for i in range(15):
        randomCharacter = random.choice(character)
        passWord.append(randomCharacter)

En vez de eso solo remplazen randomCharacter por i

 for i in range(15):
        i = random.choice(character)
        passWord.append(i)

Creo que seria buena practica hacer eso

import random
def generate_password():
    alfabeto = 'abcdefghijklmnopqrstuvwxyz'
    alfabetoM = 'ABCDEFGHIJKLMNOPQRSTUVXYZ'
    caracteres = '[email protected]#$%^&*()_+/.,'

    conbinado = alfabeto + alfabetoM + caracteres
    password =''
    for i in range(15):
        passw = random.choice(conbinado)
        password += passw
    return password
def run():
    password = generate_password()
    print("tu nueva password es: ", password)

if __name__ == "__main__":
    run()

Un par de cosas que no veo mucho en comentarios:

  1. No es necesario denominar como list() cuando usás la librería string.
  2. string.ascii_letters te devuelve todas las letras en min. y may. y te permite ahorrarte una línea.
let_char = string.ascii_letters
num_char = string.digits
sym_char = string.punctuation

all_char = let_char + num_char + sym_char
import random
import string

def generar_contrasena():

    caracter = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
    contasena = []

    while len(contasena) < 16:
        caracteres = random.choice(caracter)
        contasena.append(caracteres)

    contasena = "".join(contasena)
    return contasena

def run():

    contrasena = generar_contrasena()
    print(f"Tu nueva contrasena es: {contrasena}")


run()

CÓDIGO DE LA CLASE:

import random


def generador_contrasena():
    mayusculas = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    minusculas = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
    simbolos = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']
    numeros = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range(15):
        caracteres_random = random.choice(caracteres)
        contrasena.append(caracteres_random)

    contrasena = "".join(contrasena)
    return contrasena

    
def run():
    contrasena = generador_contrasena()
    print('Tu nueva contraseña es: ' + contrasena)

if __name__ == '__main__':
    run()

Aqui tienen mi código. Aparte, lo personalicé para que puedan poner la longitud que quieran

import random

# Function - Create an array with all the mayus, minus, nums and chars in the keyboard, and join them into an array
def passwordGenerator(length):
    MAYUS = [
        "A",
        "B",
        "C",
        "D",
        "E",
        "F",
        "G",
        "H",
        "I",
        "J",
        "K",
        "L",
        "M",
        "N",
        "Ñ",
        "O",
        "P",
        "Q",
        "R",
        "S",
        "T",
        "U",
        "V",
        "X",
        "Y",
        "Z",
    ]
    MINUS = [
        "a",
        "b",
        "c",
        "d",
        "e",
        "f",
        "g",
        "h",
        "i",
        "j",
        "k",
        "l",
        "m",
        "n",
        "ñ",
        "o",
        "p",
        "q",
        "r",
        "s",
        "t",
        "u",
        "v",
        "x",
        "y",
        "z",
    ]
    NUMS = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
    CHARS = [
        "*",
        "+",
        "-",
        "/",
        "@",
        "_",
        "?",
        "!",
        "[",
        "{",
        "(",
        ")",
        "}",
        "]",
        ",",
        ";",
        ".",
        ">",
        "<",
        "~",
        "°",
        "^",
        "&",
        "$",
        "#",
        '"',
    ]

    characters = MAYUS + MINUS + NUMS + CHARS

    secret = []

    for i in range(length):
        character_random = random.choice(characters)
        secret.append(character_random)

    secret = "".join(secret)
    return secret

pLength= input("Type the length that you want for you password: ")
password = passwordGenerator(int(pLength))
print(f"You password is {password}")

Aqui les dejo mi version sin usar listas solo strings y con un poco mas de validaciones, ademas le pregunto al ususario por el tamaño de la contraseña. Tambien use la libreria strings “https://docs.python.org/3/library/string.html

import random
import string


def psw_generator(size):
    seed = string.punctuation + string.hexdigits
    password = ""
    
    while len(password) < size:
        password += random.choice(seed)
    
    return password


def run():
    while True:
        try:
            size = int(input("How many characters for your password: "))
        except ValueError:
            print('Please enter a valid number')
            continue
        break

    print("Your new password is: " + psw_generator(size))


if __name__ == "__main__":
    run()

Contraseña de 4000 caracteres XD

Código

import random
import string

def new_passwd(long):
    caracter = string.ascii_lowercase + string.digits + string.punctuation + string.ascii_uppercase
    passwd=""
    for i in range(0,long):
        passwd+=random.choice(caracter)
    return passwd
    
def run():
    long=0
    while True:
        long = int(input("Tamaño de la contraseña: "))
        if long < 8:
            print("Se recomienda una contaseña 8 caracteres")
        else:
            break
    
    passwd = new_passwd(long) 
    print(f"Contraseña: {passwd}")
 

if __name__ == '__main__':
    run()

Tengo casi 3 años Programando (JS), nunca me habia emocionado tanto con algo tan pequeño como un generador de contraseñas… Y mira que es tonto, pero en lo personal, pienso que es genial como la programacion y el nunca parar de aprender es tan facinante y tan emocionante.

Sigan Adelante [email protected]! Programar es una de las pocas cosas lindas que nos regala el mundo.

No todas las contraseñas son de 15 caracteres, algunas son 10, incluso de 8. Por eso en la función Run pregunto al usuario cuantos caracteres desea ingresar, y esa variable se la envío a la función, por ejemplo, si el usuario ingresa 7 se va a generar una contraseña de solo 7 caracteres.
¡Espero les sirva! 🙂

import random

def generar_contrasena(cantidad_caracteres):
    mayusculas = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
    minusculas = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
    simbolos = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    numeros = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']
    
    caracteres = mayusculas + minusculas + simbolos + numeros
    
    contrasena = []
    
    for i in range(cantidad_caracteres):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)
        
    contrasena = "".join(contrasena)
    return contrasena
    
    
def run():
    cantidad_caracteres = int(input("¿Cuantos caracteres desea generar? "))
    contrasena = generar_contrasena(cantidad_caracteres)
    print("Tu nueva contraseña es: " + contrasena)


if __name__ == '__main__':
    run()

Hola, junte los proyectos del curso en un solo programa navegable. Saludos 😃

import random
import time
from os import system, name

separador = "-" * 46

def limpiar_pantalla():
    if name == "nt":
        system("cls")
    else:
        system("clear")

def entero_op (numero):
    try:
        entero = int(numero)
        if entero in range(1,6):
            return entero
        else:
            return False
    except:
        return False
    
def entero (numero):
    try:
        entero = int(numero)
        return entero
    except:
        return False

def palindromo (palabra):
    palabra = palabra.lower()
    if palabra == palabra[::-1]:
        return f"La palabra {palabra.capitalize()} es un palindromo."
    else:
        return f"La palabra {palabra.capitalize()} no es un palindromo."

def primalidad (numero):
    contador = 0
    for i in range(1, numero + 1):
        if numero % i == 0:
            contador += 1
    if contador == 2:
        return f"El {numero} es un número primo."
    else:
        return f"El {numero} no es un número primo."
    
def videojuego ():
    numero = random.randrange(1, 10)
    print("Estoy pensando en un número...")
    time.sleep(3)
    print("¡Lo tengo! Advina que número tengo")
    print(separador)
    while True:
        num_jugador = input("Ingresa un número: ")
        print(separador)
        if entero(num_jugador) == numero:
            print("Adivinaste el número")
            print(separador)
            break
        elif entero(num_jugador) > numero:
            print("El número que ingresaste es mayor a mi número")
            print(separador)
        elif entero(num_jugador) < numero:
            print("El número que ingresaste es menor a mi número")
            print(separador)
        

def pass_generator ():
    mayusculas = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
                  'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
                  'V', 'X', 'Y', 'Z']

    minus = " ".join(mayusculas).lower()
    minus = minus.split(" ")

    numeros = [str(numero) for numero in range(1, 9 + 1)]

    chars = ['*', '+', '-', '/', '@', '_', '?',
            '!', '[', '{', '(', ')', '}',']', ',',
            ';', '.', '>', '<', '~', '°', '^', '&',
            '$', '#', '"']

    caracteres = mayusculas + minus + numeros + chars
    random.shuffle(caracteres)
    password = list()
    
    for x in range (15):
        caracter = random.choice(caracteres)
        password.append(caracter)
    password = "".join(password)
    return password

def run ():
    titulo = "Proyectos del curso de Python básico de Platzi"
    separador = "-" * len(titulo)
    print(separador)
    menu = "1.- Programa de los palíndromos\n2.- Prueba de primalidad\n3.- Videojuego númerico\n4.- Generador de contraseñas\n5.- Salir"
    
    while True:
        print(titulo)
        print(separador)
        print(menu)
        print(separador)
        opcion = input("Elige la opción deseada: ")
        print(separador)
        if entero_op(opcion) == False:
            print("Opción inválida, solo se aceptan números enteros que esten entre 1 y 4")
            print(separador)
            
        while entero_op(opcion) == 1:
            limpiar_pantalla()
            print("Verificación de palíndromos")
            palabra = input("Ingresa una palabra: ")
            print(separador)
            print(palindromo(palabra))
            print(separador)
            nueva_op = input("Presiona 1 para volver al menú principal o cualquier otra tecla para ingresar una nueva palabra: ")
            print(separador)
            if nueva_op == "1":
                limpiar_pantalla()
                break
        
        while entero_op(opcion) == 2:
            limpiar_pantalla()
            print("Prueba de primalidad")
            numero = input("Ingresa un número: ")
            print(separador)
            if entero(numero) != False:
                print(primalidad(entero(numero)))
                print(separador)
                nueva_op = input("Presiona 1 para volver al menú principal o cualquier otra tecla para ingresar un nuevo número: ")
                print(separador)
                if nueva_op == "1":
                    limpiar_pantalla()
                    break
                
        while entero_op(opcion) == 3:
            limpiar_pantalla()
            videojuego()
            nueva_op = input("Presiona 1 para volver al menú principal o cualquier otra tecla para jugar otra vez: ")
            print(separador)
            if nueva_op == "1":
                limpiar_pantalla()
                break
        
        while entero_op(opcion) == 4:
            limpiar_pantalla()
            print("Generando contraseña, espere un momento...")
            time.sleep(3)
            print(f"Su nueva contraseña es: {pass_generator()}")
            print(separador)
            nueva_op = input("Presiona 1 para volver al menú principal o cualquier otra tecla para generar una nueva contraseña: ")
            print(separador)
            if nueva_op == "1":
                limpiar_pantalla()
                break
            
        if entero_op(opcion) == 5:
            print("Finalizando ejecución...")
            time.sleep(3)
            print("Ejecución finalizada")
            print(separador)
            break
                
                
if __name__ == '__main__':
    run()

Aquí incluyo mi cóidgo con la libreria paperclip para que la contraseña quede en el portapapeles
Se instala primero el modulo paperclip:

pip install pyperclip

Luego va el siguiente código y cuando termina, la contraseña está lista para pegar en donde lo necesites

import random
import pyperclip as pc

def pass_generator():
    limit = int(input('¿Cuántos caracteres debe tener tu contraseña? '))
    MAYUS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
    MINUS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
    NUMS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    CHARS = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']

    caracteres = MAYUS + MINUS + NUMS + CHARS

    password = []

    for i in range(limit):
        caracter_random = random.choice(caracteres)
        password.append(caracter_random)

    password = ''.join(password)
    return password

def run():
    new_password = pass_generator()
    print('Tu nueva contraseña es: ' + new_password)
    pc.copy(new_password)
    return new_password


if __name__ == '__main__':
    run()

Hice mi version jeje pero falto meterle caracteres , ahortia solo genera letras y numeros.

import random



def main():
    letras = ('a','b','c','d','e','f','g','h','i','j','k','l','m')
    numeros= ('1','2','3','4','5','6','7','8','9')
    caracteres=('!','$','@','+','-','*','?','¿')
    mayusculas =('A','E','I','O','U','Z','M','N','L','R')
    lista=[]

    print("""
     
     ******************* BIENVENIDO AL GENERADOR DE CONTRASEÑAS *********************
     1.- Generar una contraseña de puros numeros
     2.- Generar una contraseña de numeros y letras
    
    """)

    opcion=input("Ingresa la opción: ")
    longPassword=int(input('ingresa el tamaño de tu contraseña: '))


    if (opcion=='1'):

        for contador in range(longPassword):
            temp=random.choice(letras)
            lista.append(temp)

        for contador in lista:
            print(contador, end="")


    elif(opcion=='2'):

         if(longPassword%2==0):

             cantidad=int(longPassword/2)

             for contador in range(cantidad):
                 temp = random.choice(letras)
                 lista.append(temp)
                 temp2 = random.choice(numeros)
                 lista.append(temp2)

             for contador in lista:
                 print(contador, end="")
         else:

             for contador in range(longPassword):

                 temp = longPassword -3
                 if contador <= temp-1:
                    temp = random.choice(letras)
                    lista.append(temp)

                 if (contador <=2):
                    temp2 = random.choice(numeros)
                    lista.append(temp2)
                 print(contador)

             for contador in lista:
                 print(contador, end="")


if __name__ == '__main__':
     main()


Dado que la construcción de la contraseña depende de la aleatoriedad, puede darse el caso de que el programa genere una contraseña sin ninguna letra, número u símbolo. Eso podría considerarse una contraseña insegura.

Además, es tedioso que el usuario tenga que ejecutar el programa de nuevo cada vez que quiera una nueva contraseña. Por esa razón, incluí en mi programa;

  1. Una función que garantice la seguridad básica de la contraseña asegurando que la contraseña contiene al menos un carácter en mayúscula, un carácter en minúscula, un número y un símbolo.

  2. Una pregunta que le permita al usuario generar o no una nueva contraseña sin ejecutar nuevamente el programa.


Observación. El segundo punto genera un nuevo problema; Existe la posibilidad de que la contraseña se repita. Por tanto, sería apropiado evitar ese error comparando la nueva contraseña generada con toda aquella que se haya generado con anterioridad.

Lo anterior llevado a código;


Agradezco cualquier sugerencia de optimización del programa.

import random

def generate_pass(len_pass = 10):

MAYUS = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 
         'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z')
MINUS = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 
         'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z')
NUMS = ('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')
CHARS = ('*', '+', '-', '/', '@', '_', '?', '!', '[', '{', 
         '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"')


CHARACTERS = MAYUS + MINUS + NUMS + CHARS

password = [ random.choice(CHARACTERS) for character in range(len_pass)]

password = ''.join(password)

return password

if name==‘main’:
password = generate_pass(len_pass = 15)
print(password)

Me parece un poco infeciente hacer listas con todos los caracteres que podemos usar.

Prefiero usar el módulo incorporado (built-in) string, el cual contiene todos los carácteres que pueden ser usados en Python.

Para obtener un string con todos los caracteres validos puedes:

import string as s

valid_characters = s.ascii_letters + s.digits + s.punctuation

Siendo que ascii_letters contiene letras minúsculas y mayúsculas, digits los números del 1 al 10, y punctuation, simbolos de puntuación validos.

Les dejo mi código, espero que les sirva de referencia y sobretodo que lo puedan entender 😃

Así me quedó:

import random
mayusculas=['A','B','C','D','E','F','G','I','J','K']
minusculas=['a','b','c','d','e','f','g','x','y','o']
numeros=['1','2','3','4','5','6','7','9','8','0']
caracteres=['/','.','%','&','_','"','#','$','▼','!']
contador=1
palabra=''
while contador<=25:
  if contador<5:
    palabra=palabra+mayusculas[random.randint(0,9)]
  elif contador<11:
    palabra=palabra+numeros[random.randint(0,9)]
  elif contador<20:
    palabra=palabra+caracteres[random.randint(0,9)]
  else:
    palabra=palabra+minusculas[random.randint(0,9)] 
  contador=contador+1

print('La clave es '+ palabra)

Proyecto: generador de contraseña

Use tuplas dentro de un diccionario en vez de listas sueltas por:

  • La inmutabilidad de las tuplas la hacen mas rapidas de iterar (recorrer) que las listas, como vimos en la clase de tuplas. Ademas sus valores almacenados en la secuencia nunca cambiaran.
  • Las tuplas dentro del diccionario hacen su referencia mucho mas facil de leer.

Otra manera de obtener los caracteres es por medio del codigo ascii para no escribir cada caracter:

def password_gen():
    characters = []                     #se declara la lista
    for chars in range(33,58):          #agregando en el rango de caracteres y numeros
        characters.append(chr(chars))
    for chars in range(65,91):          #agregando en el rango de mayusculas
        characters.append(chr(chars))
    for chars in range(97,123):         #agregando en el rango de minusculas
        characters.append(chr(chars))

    password = []                       #declarando y generando password
    for i in range(15):
        password.append(random.choice(characters))
    
    password = ''.join(password)        #metodo para convertir pass en string
    return password                     #regresando el valor de pass 

Les dejo el código comentado para facilitar el entendimiento del mismo.

import random                    # importar modulo random para poder utilizar los metodos contenidos en él

def generate_password():
    mayus = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
    minus = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
    charts = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', '.', '>', '<', '&', '$', '#', '"']
    num = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    
    caracters = mayus + minus + charts + num  # Suma los elementos de las listas

    password = []
    
    for i in range (15):
        caracter_random = random.choice(caracters)  # Escoge aleatoriamente elementos en un rango X de repeticiones dictados por el for
        password.append(caracter_random)            # Añade el nuevo elemento 'caracter_random' la lista 'passowrd'

    password = "".join(password)  # .join() es un metodo para convertir a string una lista
    return password               # Recordar utilizar return para que al terminar la operación esta se guarde y pueda ser empleada
                                  # en la siguiente función

def run():
    password = generate_password()
    print('Esta es tu contraseña: ' + password)


if __name__ == '__main__':
    run()

También se puede trabajar directamente con un string, el valor que toma con .choice(lista) lo podemos convertir directamente a caracter con (nombre de variable)[0] e ir sumando en cada vuelta.

import random

def generar_contrasena():
mayusculas = [“A”,“B”,“C”,“D”,“E”]
minusculas = [“a”,“b”,“c”,“d”,“e”]
simbolos = ["!","#","&"]
numeros = [“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”,“0”]

caracteres = mayusculas + minusculas + simbolos + numeros

contrasena = []

for i in range(15):
    caracter_random = random.choice(caracteres)
    contrasena.append(caracter_random)

contrasena = ''.join(contrasena)
return contrasena

def run():
contrasena = generar_contrasena()
print("Tu nueva contraseña es: " + contrasena)

if name==‘main’:
run()

gracias por mucho

import random
def generar_contrasena():
    MAYUS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 
    'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
    MINUS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 
    'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
    NUMS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    CHARS = ['*', '+', '-', '/', '@', '_', '?', '!', '[',
     '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']
    
    caracteres = MAYUS + MINUS + NUMS + CHARS

    contrasena = []

    for i in range(15):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)
    contrasena = "".join(contrasena)
    return contrasena
def run():
    password = generar_contrasena()
    print('Tu contrasena es: ' + password)
if __name__ == '__main__':
    run()

de algunos comentarios tome algunas ideas para minimizar el codigo al maximo que pude.

import random
import string

def generar_contrasena():  
     caracteres = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
    long=int(input("longitud de la contraseña: "))
    contrasena = "".join([f'{random.choice(caracteres)}' for i in range(long)])
    return contrasena


def run():
    contrasena = generar_contrasena()
    print('Tu nueva contraseña es: ' + contrasena)


if __name__ == '__main__':
    run()

Código en inglés 😃

import random

def password_generator():
uppers = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’, ‘J’, ‘K’, ‘L’, ‘M’, ‘N’, ‘O’, ‘P’, ‘Q’, ‘R’, ‘S’, ‘T’, ‘U’, ‘V’, ‘X’, ‘Y’, ‘Z’]
lowers = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘x’, ‘y’, ‘z’]
symbols = [’*’, ‘+’, ‘-’, ‘/’, ‘@’, ‘_’, ‘?’, ‘!’, ‘[’, ‘{’, ‘(’, ‘)’, ‘}’, ‘]’, ‘,’, ‘;’, ‘.’, ‘>’, ‘<’, ‘~’, ‘°’, ‘^’, ‘&’, ‘$’, ‘#’, ‘"’]
numbers = [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘0’]

characters = uppers + lowers + symbols + numbers

password = []

for i in range(15):
    char_random = random.choice(characters)
    password.append(char_random)

password = "".join(password)
return password

def run():
password = password_generator()
print('Your new password: ’ + password)

if name == ‘main’:
run()

import random
import string


def generar_contrasena(largominimo=4, largomaximo=10):
    # list(string.ascii_lowercase) # para generar una lista con todas las letras minusculas
    # list(string.ascii_lowercase.upper()) # para generar una lista con todas las letras mayusculas
    minusculas = string.ascii_lowercase
    mayusculas = minusculas.upper()
    numeros = '1234567890'
    simbolos = '[email protected]#$%&*()'
    caracteres_alfabeto = minusculas + mayusculas
    caracteres_numericosimbolos = numeros + simbolos

    contrasena = ''
    largo = random.randint(largominimo, largomaximo)
    for i in range(largo):
        if i % 2 == 0:
            contrasena += random.choice(caracteres_alfabeto)
        else:
            contrasena += random.choice(caracteres_numericosimbolos)

    return contrasena


def run():
    contrasena = generar_contrasena(8,16)
    print(f'Tu nueva contraseña es: {contrasena}')


if __name__ == "__main__":
    run()

Me gusta lo segura que es mi contraseña

Todo ese ciclo for se puede sustituir por

    password = ''.join(random.sample(all_characters, n_characters))
    return password

Utilizo un funcion de la librería random, que devuelve una lista de longitud particular de elementos elegidos y el ‘’.join par convertir la lista en string

Les comparto mis apuntes y apreciaciones de este algoritmo:

Mechanism of password generator

In a given function called generator() there are 4 lists containing upper cases, lower cases, integers and symbols. In order to be able to execute the random.choice() method those 4 lists are joined together in a variable denominated chars.

This method will be runned inside a for with a given range of executions, alocating the random choices within a variable named random_chars and then adding them to variable password.

After the mentioned cicle is used the “”.join(random_chars) method that joins all items in a tuple into a string.

Code

import random

def generator():
    upper_cases = ['A', 'B', 'C', 'D', 'E']
    lower_cases = ['a', 'c', 'e', 'g', 'h', 'j']
    symbols = ['*', '?', '¿', '¡', '!', '#', '$', '%', '&', '/', '\\']
    numbers = ['1', '2', '3', '4', '5', '6','7','8','9','0']

    chars = upper_cases + lower_cases + symbols + numbers
    password = []

    for i in range(20):
        random_chars = random.choice(chars)
        password.append(random_chars)

    password = "".join(password)
    return password

def main():
    print('Password generator V0.1')
    password = generator()
    print('Your new password is' + password)


if __name__ == '__main__':
    main()

.join() method

This method take all items of an iterable and joins them into one string. A string must be specified as the separator (between the " "). In the case above there is no separator because the password cannot have spaces between characters. The syntax is:

string.join(iterable)

random.choice() method

This method returns a random element from a non-empty sequence. For instance, we can use this random.choice() for selecting a random password from a word-list selecting a random item from the available data. The syntax is:

random.choice(sequence)

import random
import string


def generar_contrasena():
    mayusculas=[]
    mayusculas[:0]= string.ascii_uppercase
    minusculas=[]
    minusculas[:0]= string.ascii_lowercase
    numeros=[]
    numeros[:0]= string.digits
    simbolos=[]
    simbolos[:0]= string.punctuation
    print(string.punctuation) # observa los caracteres de simbolo que podría contener

    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range(15):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)

    contrasena = "".join(contrasena)
    return contrasena


def run():
    contrasena = generar_contrasena()
    print('Tu nueva contraseña es: ' + contrasena)


if __name__ == '__main__':
    run()

Esta es mi solución cree un metodo que convierte enteros a letras, segun su valor en ASCII puede devolver o una lista de mayusculas o una lista de minusculas:

import random

def convertir_a_letra(es_mayusculas, num_letras = 26):

    letras = []
    tipo_letra = 0

    if es_mayusculas == True:
        tipo_letra = 65
    else:
        tipo_letra = 97
    
    for i in range(num_letras):
        letra = chr(tipo_letra+i)
        letras.append(letra)

    return letras

def generar_contrasena():
  
    mayusculas = convertir_a_letra(True)

    minusculas = convertir_a_letra(False)

    numeros = []

    for n in range(10):
        numeros.append(str(n))
    
    caracteres = minusculas + mayusculas + numeros
    contrasena = []

    for i in range(15):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)

    contrasena = ''.join(contrasena)

    return contrasena

    
def run():
    contrasena = generar_contrasena()
    print(f'La contraseña generada es: {contrasena}')

if __name__ == "__main__":
    run()

Espero sea de ayuda 😉

Mi versión de la práctica. 😃

#!/usr/bin/python

import random

chars = []

def init_char_list():
	global chars
	uppercase = []
	lowercase = []
	symbols = []
	numbers = []

	for i in range(27):
		uppercase.append(chr(97 + i))
		lowercase.append(chr(65 + i))

	for i in range(11):
		numbers.append(chr(48 + i))

	for i in range(7):
		symbols.append(chr(33 + i))

	chars = uppercase + lowercase + numbers + symbols


def generate_passwd(length):
	passwd = []
	for i in range(length):
		char = random.choice(chars)
		passwd.append(char)

	return ''.join(passwd)


def run():
	init_char_list()
	passwd_length = 45
	passwd = generate_passwd(passwd_length)
	print(passwd)


if __name__ == '__main__':
	run()

Un generador de contraseñas es lo último que pensé que haríamos en el curso, estuvo genial!

Creo que en el ciclo for, lo mejor hubiera sido, en vez de crear la variable i, usar la variable caracter random, porque sino queda sin utilizar.

Realice un pequeño ajuste al código, que permite que el usuario elija de cuantos caracteres desea que sea su contraseña

import random

def generar_contrasena(n):
    mayusculas = ["A", "B", "C", "D", "E", "F", "G"]
    minusculas = ["a", "b", "c", "d", "e", "f", "g"]
    simbolos = ["!", "#", "$", "&", "/", "?"]
    numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
    
    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range (n):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)

    contrasena = "".join(contrasena)
    return contrasena

def run():
    n_caracteres = int(input("¿De cuantos caracteres deseas tu contraseña?"))
    contrasena = generar_contrasena(n_caracteres)
    print(f"tu nueva contaseña es {contrasena}")


if __name__ == "__main__":
    run()```

Etra solucion al proyecto de contraseñas

import random

def genera_pwd(cant_char):
lista=range(33,127)
lista_ascil=list(lista)
lista_aux= random.sample(lista_ascil,cant_char)
pwd=""
for i in lista_aux:
pwd = pwd + chr(i)

return pwd.strip()

def run():
amplitud=int(input("De que longitud desea la contraseña: "))
print(str(genera_pwd(amplitud)))

if name== ‘main’:
run()

Aquí mi código con colores para que el usuario identifique su contraseña y si cometió algún error

Para la construcción de la cadena de llaves lo que hice fue repetir 3 veces los dígitos para equilibrar y que a la hora de construirla haya equidad incidencia de números en la contraseña.

charkeys = string.digits + string.ascii_uppercase + string.digits + string.ascii_lowercase + string.digits

Aquí mi solución:

import random

def defineElements(element):
    
    if element == 0:
        return ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z')
    elif element ==1:
        return ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z')
    elif element == 2:
        return ('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')
    else:
        return ('*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"')

def run():
    password = ""

    while len(password) < 16:
        characters = defineElements(random.randint(0, 3))
        password += characters[random.randint(0, len(characters))]
    
    return password

if __name__ == '__main__':
    print("Tu nueva contrasena es: " + run())

Les dejo el codigo para hacerlo con:

“randint” en vez de “random.choice”.

from random import randint


def generatepass():
    numeros = ["1","2","3","4","5","6","7","8","9"] 
    mayusculas = ["A","B","C","D","E","F","G","H"]
    minusculas = ["a","b","c","d","e","f","g","h"]   
    simbolos = ["/","*","%","@","#","$"]
    conjunto = numeros + mayusculas + minusculas + simbolos
    generatepass = []

    for i in range(10):
        indice = randint(0,len(conjunto))
        indice = conjunto[indice]
        generatepass.append(indice)
        
    generatepass = ''.join(generatepass)
    return generatepass

def run():
    passw = generatepass()
    print("Tu contraseña es " + passw)




    


if __name__ == "__main__":
    run()

El siguiente codigo lo escribir antes de leer los comentarios y enterarme que existe la libreria string y te da los caracteres que necesitas, me base en la tabla ASCII para hacer mi propuesta del generador, creo que es mas rebuscado mi codigo jejeje

import random

def minuscula():
    return chr(random.randint(97,122))


def mayuscula():
    return chr(random.randint(65,90))


def numero():
    return chr(random.randint(48,57))


def caracter():
    #4 bloques de codigo ASCII para caracteres que no son letras o numeros
    seleccionar=random.randint(1,4)
    especial=''
    if seleccionar==1:
        especial=chr(random.randint(33,47))
    elif seleccionar==2:
        especial=chr(random.randint(58,64))
    elif seleccionar==3:
        especial=chr(random.randint(91,96))
    elif seleccionar==4:
        especial=chr(random.randint(123,126))
    return especial

def generador_contrasena():
    listaCaracteres=[]
    for i in range(15):
        eleccion=random.randint(1,4)
        if eleccion==1:
            listaCaracteres.append(minuscula())
        elif eleccion==2:
            listaCaracteres.append(mayuscula())
        elif eleccion==3:
            listaCaracteres.append(numero())
        elif eleccion==4:
            listaCaracteres.append(caracter())
    contrasenia="".join(listaCaracteres)
    return contrasenia

    
def run():        
    print("Contraseña sugerida: "+generador_contrasena())


if __name__=="__main__":
    run()

Comparto mis apuntes:

Comparto mi solución del problema

<import random 
def generarConstrasena():
    mayuscula = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
    minuscula = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
    numero = ['0','1','2','3','4','5','6','7','8','9']
    simbolo = ['!','#','$','%','&','/','(','=','?','¿','¡']

    caracteres = mayuscula + minuscula + simbolo + numero
    contrasena = []

    for i in range(15):
        caracterRandom = random.choice(caracteres)
        contrasena.append(caracterRandom)

    contrasena = ''.join(contrasena)
    return contrasena

def run():
    contrasena = generarConstrasena()
    print('Tu nueva contrasena es: ', contrasena)

if __name__ == '__main__':
    run()> 

Antes de ver la clase realicé el ejercico por mi cuenta.
Resultó en lo siguiente:

mayus="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
lower="abcdefghijklmnopqrstuvwxyz"
numbe="0123456789"
speci="!#$%&/(=?¿¡"

def contrasena(limite):
    password=""
    for i in range (0,limite):
        tipo_char=random.randint(1,4)
        if tipo_char==1:
            elemento=random.randint(0,24)
            password=password+mayus[elemento]
            continue
        elif tipo_char==2:
            elemento=random.randint(0,24)
            password=password+lower[elemento]
            continue
        elif tipo_char==3:
            elemento=random.randint(0,9)
            password=password+numbe[elemento]
            continue
        else:
            elemento=random.randint(0,11)
            password=password+speci[elemento]
            continue
    return(password)


def run():
    limite=int(input("¿Cuántos caracteres requiere tu contraseña?"))
    password=contrasena(limite)
    print("Tu contraseña segura es " + password)


if __name__=="__main__":
    run()

Acá mi versión del generador de contraseñas, con una pequeña animación en el título y también uso de la librería string:

import os
import random
import time
import string

def title_with_effect(title):
    for i in range(len(title)):
        # Create list
        text = list(title.upper())
        # Modify char
        text[i] = title[i].lower()
        # Join full text
        text = "".join(text)
        # Print title
        print_title(text)
        # Wait a moment
        time.sleep(.05)

def print_title(title):
    os.system('clear')
    print('=======================================')
    print("         %s            " % (title))
    print('=======================================')

def create_password(length):
    full_chars = string.ascii_uppercase + string.ascii_lowercase + string.punctuation + string.digits

    password = []

    for i in range(length):
        password.append(random.SystemRandom().choice(full_chars))
    
    return "".join(password)

def run():
    title = "password generator"

    title_with_effect(title)
    print_title(title.upper())

    try:
        length = int(input("Indique la longitud deseada: \n"))
        password = create_password(length)
        print("Password con longitud %d: %s" % (length, password))
    except:
        print("Numero inválido")

if __name__ == '__main__':
    run()

Yo trabaje solo con strings:

def generador():
    _CHARS = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']
    chars = ''
    MAYUS = "ABCDEFGHIJKLMNÑOPKRSTUVWXYZ"
    minus = ''
    nums = ''
    alfabeto_all = ''
    generado = ''

    for element in MAYUS:
        minus += element.lower()
    
    for num in range(10):
        nums += str(num)
    
    for item in _CHARS:
        chars += item
    
    alfabeto_all = minus + MAYUS + nums + chars
    for i in range(15):
        generado += alfabeto_all[random.randint(0, len(alfabeto_all)-1)]
    return generado


def run():
    generado = generador()
    print(f'CONTRASEÑA GENERADA: {generado}')


if __name__ == '__main__':
    run()

De esta manera poder importa el abecedario y dejarlo como una lsita



import string
def listAlphabet():
return list(string.ascii_lowercase)
print(listAlphabet())
import random


upper_case_chars = 'A B C D E F G H I J K L M N O P Q R S T U V W X Y Z'
lower_case_chars = upper_case_chars.lower()
special_chars = '! @ # $ % ^ & * * - + |'
numeric_chars = '1 2 3 4 5 6 7 8 9 0'

chars_array = (upper_case_chars + lower_case_chars + special_chars + numeric_chars).split()


def generatePassword(password_length):
    new_password = ''

    while(len(new_password) < password_length):
        random_number = random.randrange(0,len(chars_array))
        new_password = new_password + chars_array[random_number]

    return new_password


def run():
    new_password = generatePassword(7)
    print(f"Your new password is : {new_password}")


if __name__ == "__main__":
    run()

Se podrían haber generados las listas con ciclos For verdad?? en vez de escribirlos manualmente.

Preferí usar tuplas en su lugar:

import random


def generate_pass():
  MAYUS = ('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z')
  MINUS = ('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z')
  NUMBERS = ('0','1','2','3','4','5','6','7','8','9')
  symbols = ('!','@','#','%','&','/','(',')','=','?','¿')
  ALL_CHARS = MAYUS + MINUS + NUMBERS + symbols
  passw = []  
  for i in range(15):
    char = random.choice(ALL_CHARS)
    passw.append(char)
    passw_str = ''.join(passw)
  return passw_str


def run():
  password = generate_pass()
  print("Tu nueva contraseña es: "+password)


if __name__ == '__main__':
  run()

Información resumida de esta clase
#EstudiantesDePlatzi

  • Una buena práctica es escribir nuestro código en inglés, los nombres de los archivos, variables, etc.

  • Con .choice de random puedo elegir un carácter al azar de toda la lista

Para crear un menu rapido en consola pueden usar el paquete consolebox lo instalan con pip install consolebox

from consolebox.menubox import MenuBox # pip install consolebox
from consolebox.style import Style
import colorama # pip install colorama

def about():
    print("Programed by JordyM01")

def your_options():
    print("create a function for each option in your menu")
    a = 5
    b = 6
    print(f'addition: {a + b}')

def main():
    items = { # Menu options
        1 : "Option 1",
        2 : "About"
        }

    options = { # functions that correspond to the menu options the numeric identifier must be the same
        1 : your_options, # function name without parentheses
        7: about,
    }

    attributes = {
            "length" : 40, # Broad min 40 max 90
            "columns" : 1, # Max = 5
            "indicator" : ">>", # ==>, *, -, ::, +, @
            "alignment" : "centered", # Right, left, centered
            "enumerate" : True, # True or False
            "title" : True, # True or False
            "Title" : "Menu options", # Title text max 36 characters title must be True
            "corner" : True, # True or False
            "intersection" : True, # Intersection True or False
    }
    # use tab, directional arrows and enter to scroll, backspace to exit

    men = MenuBox(items, attributes, options)

    Style.clear() # Clean screen
    men.show() # show the menu object


if __name__ == '__main__':
    main() 

Solucion Ehercicio:

"""
    Generador de contraseña.

@author: Sebastian
"""

import random
import string
"""
   Variable pass_name es donde tengo los datos para generar la contraseña.
"""


def generar_pass(gen_pass):
    pass_final = ''
    pass_name = string.ascii_lowercase + string.ascii_uppercase + string.digits

    for i in range(gen_pass):
        tamano_lista = int(len(pass_name))
        pass_final = pass_final + \
            str(pass_name[random.randint(0, tamano_lista)])

    return pass_final


def run():
    tam_pass = int(input('Ingrese el tamaño de la contraseña: '))
    pass_fin = generar_pass(tam_pass)
    print ('Pass: ' + pass_fin)

if __name__ == '__main__':
    run()

Result:
Ingrese el tamaño de la contraseña: 10
Pass: h7B1OJoUFd

Decidi usar tuplas! Algo importante que creo que no mencionaron fue que las tuplas se pueden mutar por concatenacion

import random

def generate_pass(pass_length):
    MAYUS = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z')
    MINUS = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z')
    NUMS = ('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')
    CHARS = ('*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"')

    ALL_CHARS = MAYUS + MINUS + NUMS + CHARS
    generated_pass = []
    
    for i in range(pass_length):
        selected_char = random.choice(ALL_CHARS)
        generated_pass.append(selected_char)

    return "".join(generated_pass)

def run():
    password = generate_pass(16)
    print("Your new pass is: " + password)

if __name__ == '__main__':
    run()

import random
from unicodedata import name
def generar_contrasena():
mayusculas= [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’, ‘J’, ‘K’, ‘L’, ‘M’, ‘N’, ‘Ñ’, ‘O’, ‘P’, ‘Q’, ‘R’, ‘S’, ‘T’, ‘U’, ‘V’, ‘X’, ‘Y’, ‘Z’]
minusculas = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘ñ’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘x’, ‘y’, ‘z’]
simbolos = [’*’, ‘+’, ‘-’, ‘/’, ‘@’, ‘_’, ‘?’, ‘!’, ‘[’, ‘{’, ‘(’, ‘)’, ‘}’, ‘]’, ‘,’, ‘;’, ‘.’, ‘>’, ‘<’, ‘~’, ‘°’, ‘^’, ‘&’, ‘$’, ‘#’, ‘"’]
numeros = [‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘0’]

caracteres = mayusculas + minusculas + simbolos + numeros
contrasena = []


for i in range(15):
    caracter_random = random.choice(caracteres)
    contrasena.append(caracter_random)

contrasena = "".join(contrasena)
return contrasena

def run():
contrasena = generar_contrasena()
print('Tu nueva contraseña es: ’ + contrasena)

if name == ‘main’:
run()

Generador de contraseñas

>> EJEMPLO CONCISO <<

import random

def generador_contrasena():
mayuscula = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’,
‘I’, ‘J’, ‘K’, ‘L’, ‘M’, ‘N’, ‘Ñ’, ‘O’, ‘P’, ‘Q’,
‘R’, ‘S’, ‘T’, ‘U’, ‘V’, ‘W’, ‘X’, ‘Y’, ‘Z’]
numeros = [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘0’]
minusculas = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’,
‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘ñ’, ‘o’, ‘p’,
‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]
simbolos = [’!’, ‘¡’, ‘¿’, ‘?’, ‘"’, ‘#’, ‘$’, ‘%’,
’&’, ‘/’, ‘\’, ‘(’, ‘)’, ‘=’]

caracteres = mayuscula + minusculas + numeros + simbolos
contrasena = ""

# * * * * * * * * * * * *
# La parte simplificada
for i in range(15):
    contrasena += random.choice(caracteres)
return contrasena

def run():
contrasena = generador_contrasena()
print(contrasena)

if name == ‘main’:
run()

Python es una bellaza. Una pequeña revisadita a los modulos y aparecio ni mas ni menos que el modulo string, muy util para este caso:

import random
import string


def run():
    password = "".join(random.choices(string.ascii_letters + string.digits + string.punctuation, k=64))
    print(f"Tu nuevo password es: {password}.")


if __name__ == "__main__":
    run()

Geniaaaaaaaaaaaaal

Here is my code

import random
def run():
    char=int(input('How many characters do you want in your password?: '))
    numbers = ['0','1','2','3','4','5','6','7','8','9']
    mayus = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
    minus = []
    symbols=['+','-','*','/',"/",'&',"#","$","(" , ")" ]
    for i in range(len(mayus)):
        minus.append((mayus[i].lower()).strip())
    character=numbers + mayus + minus + symbols
    password=[]
    contador=0
    while contador <= char:
        password.append(random.choice(character))
        contador += 1
    print('Your password is '+ ''.join(password))    

if __name__ == '__main__':
    run()

La otra forma de hacerlo, pero no sale igual, sólo para que corra es quitar el join y poner
return str(contrasena)

Este proyecto me encantó, dejo aquí mi generador de contraseñas con un menú para poder elegir la longitud que tendrá tu password. Aprovecho para decirles que si ocupan un generador de contraseñas seguro y con bóveda de contraseñas ocupen Bitwarden

Mi código:

Generador de contraseñas

Nota: A diferencia del código realizado en clase, este tiene una mejora, por decirlo así. El programa pregunta la cantidad de caracteres que solicites desde el principio, para no estar entrando al código y modificar cada que necesites una cantidad diferente. Gracias Profe Facundo 😃

import random


def generar_contrasena(cantidad):
    mayusculas = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    minusculas = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
    simbolos = ['!', '#', '$', '&', '/', '(', ')', '¡', '_', '-']
    numeros = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range(cantidad):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)
    
    contrasena = ''.join(contrasena)
    return contrasena




def run():
    print("""
    [email protected], este es el generador de contraseñas
    by: Dryu_Jos
    """)
    cantidad = int(input('¿Cuántos caracteres quieres?: '))
    contrasena = generar_contrasena(cantidad)
    print('Tu nueva contraseña es: ' + contrasena)


if __name__ == '__main__':
    run()

Dejo aqui mi modo de hacer el generador de contraseñas… es más rustico pero bueno es lo que salió sin ver la formula del profe XD.

import random

def generar_contr():
    MAYUS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
    MINUS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
    NUMS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    CHARS = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']        
    lugar1=MAYUS[random.randint(0,25)]
    lugar2=MAYUS[random.randint(0,25)]
    lugar3=MAYUS[random.randint(0,25)]
    lugar4=NUMS[random.randint(0,9)]
    lugar5=MINUS[random.randint(0,25)]
    lugar6=MINUS[random.randint(0,25)]
    lugar7=NUMS[random.randint(0,9)]
    lugar8=CHARS[random.randint(0,25)]
    listafinal=(lugar1+lugar2+lugar3+lugar4+lugar5+lugar6+lugar7+lugar8)
    return listafinal
def run():
    contrasena=generar_contr()
    print(contrasena)


if __name__ == "__main__":
    run()

Por qué en este programa no utilizar tuplas en vez de listas, ya que no van a cambiar los valores dentro de ella, además de las ventajas que había comentado en la clase de tuplas.

Gracias por este tiempo de enseñansa Maestro!