Proyecto: generador de contraseñas

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.

Les recomiendo este libro de Python

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()```

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

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:

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()

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}")

Segun entendi en la clase anterior, es mas oportuno usar tuplas a menos que sea necesaria la lista, asi que para la creacion de las mayusculas, minusculas, numeros y simbolos creo que se seria mejor usar tupla

• He preguntado la cantidad de caracteres que desea
• Si lo desea con simbolos o no

import random

def generatorPassword(cantidad, chars):
    MAYUS = ['DATOS']
    MINUS = ['datos']
    NUMS = ['numeros']
    CHARS = ['caracteres']
    if chars == 'si':
        caracteres = MAYUS + MINUS + NUMS + CHARS
    else:
        caracteres = MAYUS + MINUS + NUMS
        
    contrasena = []
    for i in range(cantidad):
        caracterRandom = random.choice(caracteres)
        contrasena.append(caracterRandom)
    return contrasena
        
def run():
    cantidad = int(input("Ingresa la cantidad caracteres que quieres en tu nueva RandomContraña: "))
    chars = input("Desea simbolos en su contraseña? (escribir 'si' o 'no'):  ")
    contrasena = generatorPassword(cantidad, chars)
    print('Tu nueva contraseña es: ' + ''.join(contrasena))

if __name__ == '__main__':
    run()

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.

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()```

He visto este ejercicio de palíndromo, pero usado para enseñar de funciones recursivas.

Hice un programa para generar algo parecido a lo que envían los bancos en mi país al teléfono móvil, para seguridad de las transferencias de dinero por internet.

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', 'X', 'Y', 'Z']
    numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]

    caracteres = mayusculas + numeros

    contrasena = []

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

    contrasena = "".join(contrasena)
    return contrasena


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


if __name__ == "__main__":
    run() 

Les comparto mi código

# Taller:   passwork_generator 2.0
# Name: Joe O^2
# Date:	Feb/14/2023

from os import system
system('cls')

import random as Rd
import string as St


def PssGenen():
    charter=  St.ascii_lowercase+ St.ascii_uppercase+ St.punctuation
    V_charter = [charter[i] for i in range(len(charter))]
    pssCharter =[Rd.choice(V_charter) for i in range (15)]
    return ''.join(pssCharter)

def run():
    print('''
╔═══╗                    ╔╗                 ╔╗      
║╔═╗║                    ║║                ╔╝╚╗     
║╚═╝╠══╦══╦══╦╗╔╗╔╦══╦═╦═╝║╔══╦══╦═╗╔══╦═╦═╩╗╔╬══╦═╗
║╔══╣╔╗║══╣══╣╚╝╚╝║╔╗║╔╣╔╗║║╔╗║║═╣╔╗╣║═╣╔╣╔╗║║║╔╗║╔╝
║║  ║╔╗╠══╠══╠╗╔╗╔╣╚╝║║║╚╝║║╚╝║║═╣║║║║═╣║║╔╗║╚╣╚╝║║ 
╚╝  ╚╝╚╩══╩══╝╚╝╚╝╚══╩╝╚══╝╚═╗╠══╩╝╚╩══╩╝╚╝╚╩═╩══╩╝ 
                        ╔═╝║                     
                        ╚══╝''') 
    quest = input('would you like to generate  password? Y || N:\t')
    while True:
        if quest.upper() == 'Y':
            password=PssGenen()
            print(f"You password is:\t{password}")
            quest = input('would you like to generate another password?')
        else:
            print('''
████████╗██╗  ██╗ █████╗ ███╗  ██╗██╗  ██╗ ██████╗
╚══██╔══╝██║  ██║██╔══██╗████╗ ██║██║ ██╔╝██╔════╝
   ██║   ███████║███████║██╔██╗██║█████═╝ ╚█████╗ 
   ██║   ██╔══██║██╔══██║██║╚████║██╔═██╗  ╚═══██╗
   ██║   ██║  ██║██║  ██║██║ ╚███║██║ ╚██╗██████╔╝
   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚══╝╚═╝  ╚═╝╚═════╝ ''')
            break

if __name__ == '__main__':
    run()

Esta fue mi manera de hacer el código:

def password():

    import random
    import string
# Password (It's empty right now)
    final_password = ""
# Characters "list"
    characters = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
# Password length (Given by user)
    password_length = int(input("How long should the password be?: "))
    for i in range(1, password_length+1):
        # Chooses randomly a character
        password_character = random.choice(characters)
        # The character gets stored
        final_password += password_character
    # Prints the password
    print("Your new password is:", final_password)


if __name__ == "__main__":
    password()
 

import random
import time
import string


def intro():
	msg = '''
	++++++++++++++++++++++++

		PASSWORD GENERATOR

	
	# To create a safe password 
	# please write a length.

	++++++++++++++++++++++++

	'''

	print(msg)
	time.sleep(1)

def generator(longitud):
	simbolos= ['$', '#', '*', '@', '?', '!', '&', '%']
	simb = random.choice(simbolos)
	lower = string.ascii_lowercase
	upper = string.ascii_uppercase
	digit = string.digits

	characters = lower + upper + digit + simb
	passw = ''.join(random.sample(characters, longitud))
	print(f'We have generated this password {passw}')


def password():
	longitud = int(input('Enter a length for your password\n>	'))
	if longitud is str(longitud).isnumeric():
		print('Please give me just integers numbers')
	else:
		print('We are working in create your password')
		time.sleep(2)
		print('We are almost ready!')
		time.sleep(1)
		generator(longitud)


if __name__ == '__main__':
	intro()
	password()

Otra forma de obtener el array de letras

letras = []
for n in range(33,125):
    print(chr(n),end=',')
    letras.append(chr(n))
maximo=15
clave=''
while (maximo>0)    :
    clave+=letras[int(random.random()*len(letras)-1)]
    maximo=maximo-1
print( '\nnueva clave : '+clave)

Comparto el código que genere haciendo uso de algunos métodos para no tener que crear las listas manualmente

Adicional le agrego un argumento del tamaño de la contraseña, solo se agrega la librería string.

Saludos…

import random, string


def pwdGenerator(size: int):
    # tupla con números de tipo string
    num = tuple('0123456789')
    # tupla con letras de la a-z concatenado con de la A-Z.
    letters = tuple(string.ascii_letters)
    # tupla con carácteres especiales
    specialCharts = tuple('[email protected]#$%&/()=?*+-_.` ')
    # concateno tuplas
    allCharts = letters + specialCharts + num
    # variable de tipo lista
    password = []
    for i in range(size):
        selectChart = random.choice(allCharts)
        password.append(selectChart)
    
    return ''.join(password)

We have to get used to using English in everything:

import random

def generar_contrasena():
mayusculas = [‘A’, ‘B’, ‘C’, ‘E’, ‘D’, ‘F’, ‘G’]
minusculas = [‘a’, ‘b’, ‘c’, ‘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 (15):
    caracter_random = random.choice(caracteres)
    contrasena.append(caracter_random)
contrasena = "".join(contrasena)
return contrasena

def run():
contrasena = generar_contrasena()
print('tu nueva contrasena es: '+ contrasena)

if name==‘main’:
run()

Proyecto Contraseña Random ✅😊

import random

def generate_password():
    capital_letter = ['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']
    lower_case = ['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']
    numbers = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    symbols = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']

    characters = capital_letter + lower_case + numbers + symbols

    password = []

    for i in range(15):
        # Con random.choice escojo un caracter random de todo la lista
        character_random = random.choice(characters)
        # Agrego el caracter random a la lista password
        password.append(character_random)

    # Con join, junto cada elemento de la lista y en un string
    # "" es para decirle que no haya ningun caracter entre cada elemento unido
    password = "".join(password)
    return password


def run():
    # Obtengo el password random con la función y lo muestro
    password = generate_password()
    print(f"Tu nueva contraseña es: {password}")

# Se coloca para establecer que este será el archivo principal
if __name__ == '__main__':
    run()

FINO

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():
    contrasena = generar_contrasena()
    print('Tu nueva contraseña es: ' + contrasena)


if __name__ == "__main__":
    run()

Ahora si el tema es demasiado claro, muy muy bueno el profesor

Este es mi código, en realidad no me gusta el random de todos igualados en promedio, me gustaría que seleccionara más minusculas que otros caracteres, aqui a continuación:

tip: tener en cuenta que random.shuffle ordena de forma aleatoria una lista ya que tampoco quería que quedara en orden las mayusculas, minusculas y etc

import random


def generador():
    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"]
    numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
    simbolos = ["!", "#", "$", "&", "/", "(", ")", "=", "?", "¿", "¡"]

    #generador_union = mayusculas + minusculas + numeros + simbolos

    contrasena = []

    for i in range(4):
        mayusculas_random = random.choice(mayusculas)
        contrasena.append(mayusculas_random)

    for i in range(6):
        minusculas_random = random.choice(minusculas)
        contrasena.append(minusculas_random)

    for i in range(3):
        numeros_random = random.choice(numeros)
        contrasena.append(numeros_random)

    for i in range(2):
        simbolos_random = random.choice(simbolos)
        contrasena.append(simbolos_random)

    random.shuffle(contrasena)
    contrasena = "".join(contrasena)
    return contrasena   

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


if __name__ == "__main__":
    run() 

Es interesante como se puede utilizar listas en un programa

Este es mi programa, genera contraseñas de acuerdo a una longitud que le des. No vas a encontrar caracteres repetidos consecutivamente:
Utiliza diccionarios, tuplas y listas:

#este código genera contraseñas a partir de listas
#de diferentes caracteres

import random

#las tuplas nos sirven por que ninguna de estas listas cambiaran
posibilidadesCaracteres = {
1:('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'),
2:('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'),
3:('1', '2', '3', '4', '5', '6', '7', '8', '9', '0'),
4:('*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"')
}

def gen_pass(longitud):
    #bien, lo primero es que escogerá aleatoriamente entre mayusculas:1,minus:2,num:3 y char:4
    contrasena = ''
    while(len(contrasena)<=longitud):
        tupla = random.randint(1,4)
        #escogemos una tupla, y de esa un caracter aleatorio
        tupla_aux = posibilidadesCaracteres[int(tupla)]
        #seleccionamos un elemento aleatoriamente
        char_anadir = tupla_aux[random.randint(0,len(tupla_aux)-1)]
        #si el ultimo elemento es igual al que se va a añadir, escogemos otro
        if(len(contrasena)==0):
            contrasena+= char_anadir
        else:
            if(contrasena[-1]!=char_anadir):
                contrasena+= char_anadir
            else:
                while(contrasena[-1] == char_anadir):
                    #el indice negativo nos permite entrar al ultimo elemento
                    #de la string
                    char_anadir = tupla_aux[random.randint(0,len(tupla_aux)-1)]
                    if(contrasena[-1] != char_anadir): 
                        contrasena+=char_anadir
                        #terminamos el ciclo
                        break
        
        
    return contrasena

def run():
    numero = int(input('dime el numero de caracteres del cual quieres tu contraseña: \n'))
    print(gen_pass(numero))


if __name__ == '__main__':
    run()

Dejo un codigo optimizado. El que tenga duda que avise . Saludossss

<code> 

import random

def main():
    pas = chr(random.randint(65,122))
    for i in range(15):
        pas += chr(random.randint(33,122))

    print(pas)


if __name__ == '__main__':
    main()
</code>

EL ejercicio pero usando codigo ascii

Codigo Ascii

Mi ultima nota y aporte de clase de generador de contraseña (na), me gusto mucho el curso pude aprender y retroalimentar otros conceptos básicos de Python excelente 😃

"""generador de contrasenas"""
import random


def generar_contrasena()->str:
    """ Generar una contraseña aleatoria """
    contrasena:str = ""
    for i in range(15):
        contrasena += chr(random.randint(32, 126))
    return contrasena


def run() -> None:
    """ Funcion de inicializacion del programa """
    contrasena: str = generar_contrasena()
    print("Tu nueva contraseña " + contrasena)


if __name__ == "__main__":
    run()

Mi solución:

#
# programa que genera contraseña
# aleatoria de 13 caracteres
#

import string
from random import randint


def passwd_gen():
    # lista con caracteres
    chars = list(string.ascii_letters) + list(string.punctuation) + list(string.digits)
    
    c = 0
    passwd = ''
    while c < 13:
        randnum = randint(0, len(chars) - 1)
        passwd = passwd + chars[randnum]
        c += 1
    
    return passwd



if __name__ == '__main__':
    print('Your password is: {}'.format(passwd_gen()))

Se puede importar el modulo string y usar:

# todas las letras en mayuscula y minuscula
string.ascii_letters
# todas los simbolos de puntuacion
string.punctuation

Para obtenerlo sin tener que escribir uno por uno
(se puede poner en lista)

en mi ejemplo no separe cada caracter de string en un arreglo si no escribi todo un un solo string :

…
mayus = 'ABCDEFGSEMNBVCXZLÑJHGFDSAWQERTYUIOP’
minus = ‘abcdefghijklmnopqwertyuiopñk’
simbol=’!"#$%&()=??¡*][_;:'
numero =‘1234567890’
…

Es mas fácil si usamos strings y no list de caracteres, sirve igual random.choice.

Este fue mi codigo antes de ver el video.

import random

def gen_pass():
    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 = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']

    passworld = []

    def asignar_caracter(tipo):
        longitud = len(tipo)
        rando = random.randint(0,longitud) - 1
        caracter = tipo[rando]
        passworld.append(caracter)    


    for i in range(10):
        random_number = random.randint(1,4)
        if random_number == 1:
            asignar_caracter(MAYUS)
        elif random_number == 2:
            asignar_caracter(MINUS)
        elif random_number == 3:
            asignar_caracter(NUMS)
        else:
            asignar_caracter(CHARS)
    passworld = "".join(passworld)
    return passworld

def run():
    passworld = gen_pass()
    print('Tu contraseña es:', passworld)


if __name__ == '__main__':
    run()

Para los que les aparece un error de caracteres especiales como la ‘ñ’, ‘^’, etc, en la consola de python, solo agregamos esta linea de codigo al principio y listo!!

# -*- coding: utf-8 -*-

CÓDIGO FINAL

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):
        caracteres_random = random.choice(caracteres)
        contrasena.append(caracteres_random)
        
    contrasena = "".join(contrasena)
    return contrasena


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


if __name__ == '__main__' :
    run()

from cgi import print_environ
import random

def generar_contrasena():
mayusculas = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’]
minusculas = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’]
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 contrasena es: '+ contrasena)

if name == ‘main’:
run()