पासवर्ड जनरेटर को फिर से लिखना

राजनीति से बाहर के पासवर्ड

मुझे यह महसूस हुआ कि मैंने पहले ही पाँच बार पासवर्ड बनाने के लिए एक कार्य लिखा है। और उसने हर बार अलग तरीके से किया। और इसका कारण विभिन्न परियोजनाओं और उपकरणों के लिए अलग-अलग पासवर्ड की आवश्यकता है। कोई जटिल कोड नहीं होगा, बस एक सरल नए समाधान का सारांश जो कल मेरे पास आया था।

चलो सरल पासवर्ड आवश्यकताओं के साथ शुरू करते हैं:

• मनमानी लंबाई का होना चाहिए
• किसी भी मुद्रित वर्णों से मिलकर होना चाहिए

import string
import random
from typing import List

def generate_password(length: int) -> str:
     """
     Generate a password of a given `length`.
     """
     result: List[str] = []
     choices = string.printable #    ,    
     while len(result) < length:
         symbol = random.choice(string.printable)
         result.append(symbol)
     return "".join(result)

हम कोशिश करेंगे:

>>> generate_password(8)
... "1{k]/2)h"
>>> generate_password(13)
... "9ar|&:a+U]Il$"

खैर, कार्य पूरा हो गया है, हम काम के दिन के अंत तक बिल्लियों के साथ तस्वीरें देख सकते हैं।

अचानक राजनीति

, , MyDB . , :

• 8
• - (!&? )
• , bash-

, . :

• , , -
• ,

ठीक है, यह पहले से ही जटिल है, तो चलिए एक फ़ंक्शन से शुरू करते हैं generate_random_stringजो बस उनके द्वारा दिए गए यादृच्छिक रैंडम उत्पन्न करेगा।

import string
import random
from typing import List

def generate_random_string(length: int, *choices: str) -> str:
    """
    Generate a string of a given `length`.

    The result has at least one symbol from each of `choices` if `length` allows.

    Arguments:
        length -- Result string length.
        choices -- Strings with available symbols.
    """
    if not choices:
        #        ,    
        choices = (string.ascii_letters, ) 

    #      
    all_choices = "".join(choices)
    result: List[str] = []
    choice_index = 0
    while len(result) < length:
        #      , 
        #        
        if choice_index < len(choices):
            symbol = random.choice(choices[choice_index])
            result.append(symbol)
            choice_index += 1
            continue

        #        
        symbol = random.choice(all_choices)
        result.append(symbol)

    #       
    random.shuffle(result)
    return "".join(result)

तो चलो कोशिश करें:

>>> #    
>>> generate_random_string(8, string.digits)
... "59197550"
>>> #       
>>> generate_random_string(8, string.ascii_letters, "!") 
... "vIOWXN!o"

महान, यह वास्तव में एक पासवर्ड उत्पन्न करने का समय है जो हमारी सभी आवश्यकताओं को पूरा करता है।

def generate_mydb_password(length: int) -> str:
    """
    Generate a random password for MyDB of a given `length`.

    The result has at least:
    - one uppercase letter
    - one lowercase letter
    - one digit
    - one special character

    Raises:
        ValueError -- If `length` is lesser than 8.
    """
    if length < 8:
        raise ValueError("Password length should be at least 8")

    return generate_random_string(
        length,
        string.ascii_uppercase, #      
        string.ascii_lowercase, #  
        string.digits, #  
        "!&?", #  -,    
    )

यह केवल जाँच करने के लिए बनी हुई है:

>>> generate_mydb_password(8)
... "P?P1&7zL"
>>> generate_mydb_password(13)
... "tR!QslK!Sl7EO"
>>> generate_mydb_password(2)
... ValueError: Password length should be at least 8

संपूर्ण

हमने एक आसान-से-समझदार और एक ही समय में काफी यादृच्छिक पासवर्ड जनरेटर लिखा, और कार्य दिवस के अंत तक अभी भी बहुत समय है। यदि पुस्तकालय में कोई भरोसा नहीं है random, तो आप इसे अपनी पसंद के साथ बदल सकते हैं।

ध्यान देने के लिए आपको धन्यवाद!