ಪ್ರಾಜೆಕ್ಟ್ 9: ಪಾಸ್‌ವರ್ಡ್ ಜನರೇಟರ್ (Password Generator)

ಈ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಒಂದು ಸುರಕ್ಷಿತ ಮತ್ತು ಯಾದೃಚ್ಛಿಕ (random) ಪಾಸ್‌ವರ್ಡ್‌ಗಳನ್ನು ರಚಿಸುವ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ. ಬಳಕೆದಾರರು ತಮಗೆ ಬೇಕಾದ ಪಾಸ್‌ವರ್ಡ್‌ನ ಉದ್ದ, ಮತ್ತು ಅದರಲ್ಲಿ ದೊಡ್ಡಕ್ಷರಗಳು, ಚಿಕ್ಕಕ್ಷರಗಳು, ಸಂಖ್ಯೆಗಳು, ಮತ್ತು ವಿಶೇಷ ಚಿಹ್ನೆಗಳು ಇರಬೇಕೇ ಬೇಡವೇ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ಕಲಿಕೆಯ ಪರಿಕಲ್ಪನೆಗಳು

random ಮಾಡ್ಯೂಲ್ (choice, shuffle).
string ಮಾಡ್ಯೂಲ್ (ascii_letters, digits, punctuation).
ಲಿಸ್ಟ್‌ಗಳು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು.
ಬಳಕೆದಾರರಿಂದ ಇನ್‌ಪುಟ್ ಪಡೆಯುವುದು ಮತ್ತು ಅದನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು.
for ಲೂಪ್‌ಗಳು.

ಕೋಡ್

import random
import string

def generate_password(length, use_upper, use_lower, use_digits, use_symbols):
    """ಬಳಕೆದಾರರ ಆಯ್ಕೆಗಳ ಆಧಾರದ ಮೇಲೆ ಯಾದೃಚ್ಛಿಕ ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ."""

    # ಪಾಸ್‌ವರ್ಡ್‌ನಲ್ಲಿ ಬಳಸಬಹುದಾದ ಅಕ್ಷರಗಳ ಪೂಲ್ ಅನ್ನು ರಚಿಸುವುದು
    char_pool = ""
    if use_upper:
        char_pool += string.ascii_uppercase
    if use_lower:
        char_pool += string.ascii_lowercase
    if use_digits:
        char_pool += string.digits
    if use_symbols:
        char_pool += string.punctuation

    if not char_pool:
        return "Error: ದಯವಿಟ್ಟು ಕನಿಷ್ಠ ಒಂದು ಅಕ್ಷರ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆಮಾಡಿ."

    # ಯಾದೃಚ್ಛಿಕವಾಗಿ ಅಕ್ಷರಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಿ ಪಾಸ್‌ವರ್ಡ್ ರಚಿಸುವುದು
    password_list = [random.choice(char_pool) for _ in range(length)]

    # ಪಾಸ್‌ವರ್ಡ್‌ನ ಅಕ್ಷರಗಳನ್ನು ಇನ್ನಷ್ಟು ಯಾದೃಚ್ಛಿಕಗೊಳಿಸಲು ಶಫಲ್ ಮಾಡುವುದು
    random.shuffle(password_list)

    # ಲಿಸ್ಟ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪರಿವರ್ತಿಸುವುದು
    return "".join(password_list)

def main():
    """ಮುಖ್ಯ ಫಂಕ್ಷನ್."""
    print("ಪಾಸ್‌ವರ್ಡ್ ಜನರೇಟರ್‌ಗೆ ಸ್ವಾಗತ!")

    try:
        length = int(input("ಪಾಸ್‌ವರ್ಡ್‌ನ ಉದ್ದವನ್ನು ನಮೂದಿಸಿ (ಕನಿಷ್ಠ 8): "))
        if length < 8:
            print("ಸುರಕ್ಷತೆಗಾಗಿ, ದಯವಿಟ್ಟು ಕನಿಷ್ಠ 8 ಅಕ್ಷರಗಳ ಉದ್ದವನ್ನು ಆಯ್ಕೆಮಾಡಿ.")
            return

        use_upper = input("ದೊಡ್ಡಕ್ಷರಗಳನ್ನು (Uppercase) ಬಳಸಬೇಕೇ? (yes/no): ").lower() == 'yes'
        use_lower = input("ಚಿಕ್ಕಕ್ಷರಗಳನ್ನು (Lowercase) ಬಳಸಬೇಕೇ? (yes/no): ").lower() == 'yes'
        use_digits = input("ಸಂಖ್ಯೆಗಳನ್ನು (Digits) ಬಳಸಬೇಕೇ? (yes/no): ").lower() == 'yes'
        use_symbols = input("ವಿಶೇಷ ಚಿಹ್ನೆಗಳನ್ನು (Symbols) ಬಳಸಬೇಕೇ? (yes/no): ").lower() == 'yes'

        password = generate_password(length, use_upper, use_lower, use_digits, use_symbols)

        print("\nನಿಮ್ಮ ರಚಿಸಲಾದ ಪಾಸ್‌ವರ್ಡ್ ಇಲ್ಲಿದೆ:")
        print(password)

    except ValueError:
        print("ತಪ್ಪಾದ ಇನ್‌ಪುಟ್. ದಯವಿಟ್ಟು ಪಾಸ್‌ವರ್ಡ್ ಉದ್ದಕ್ಕಾಗಿ ಪೂರ್ಣ ಸಂಖ್ಯೆಯನ್ನ�� ನಮೂದಿಸಿ.")

if __name__ == "__main__":
    main()

ವಿವರಣೆ

import random, string:
- random: ಯಾದೃಚ್ಛಿಕ ಆಯ್ಕೆಗಳನ್ನು ಮಾಡಲು.
- string: string.ascii_uppercase (A-Z), string.ascii_lowercase (a-z), string.digits (0-9), ಮತ್ತು string.punctuation (!@#$...) ನಂತಹ ಮೊದಲೇ ಡಿಫೈನ್ ಮಾಡಿದ ಅಕ್ಷರ ಸೆಟ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ಪಡೆಯಲು.
generate_password(...) ಫಂಕ್ಷನ್:
- char_pool: ಇದು ಒಂದು ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್. ಬಳಕೆದಾರರ ಆಯ್ಕೆಗಳ (use_upper, use_lower, ಇತ್ಯಾದಿ) ಆಧಾರದ ಮೇಲೆ, ನಾವು ಸಂಬಂಧಿತ ಅಕ್ಷರ ಸೆಟ್‌ಗಳನ್ನು ಈ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಸೇರಿಸುತ್ತೇವೆ.
- if not char_pool:: ಬಳಕೆದಾರರು ಯಾವುದೇ ಅಕ್ಷರ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆ ಮಾಡದಿದ್ದರೆ, ಪಾಸ್‌ವರ್ಡ್ ರಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಅಂತಹ ಸಂದರ್ಭದಲ್ಲಿ ಎರರ್ ಸಂದೇಶವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.
- ಲಿಸ್ಟ್ ಕಾಂಪ್ರಹೆನ್ಷನ್: [random.choice(char_pool) for _ in range(length)]
  - range(length): ನಮಗೆ ಬೇಕಾದ ಪಾಸ್‌ವರ್ಡ್ ಉದ್ದದಷ್ಟು ಬಾರಿ ಲೂಪ್ ಚಲಿಸುತ್ತದೆ.
  - random.choice(char_pool): ಪ್ರತಿ ಬಾರಿ, char_pool ನಿಂದ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.
  - ಈ ಎಲ್ಲಾ ಯಾದೃಚ್ಛಿಕ ಅಕ್ಷರಗಳನ್ನು password_list ಎಂಬ ಲಿಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.
- random.shuffle(password_list): ಪಾಸ್‌ವರ್ಡ್‌ನ ಭದ್ರತೆಯನ್ನು ಇನ್ನಷ್ಟು ಹೆಚ್ಚಿಸಲು, ಲಿಸ್ಟ್‌ನಲ್ಲಿರುವ ಅಕ್ಷರಗಳ ಕ್ರಮವನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಬದಲಾಯಿಸುತ್ತೇವೆ (ಶಫಲ್ ಮಾಡುತ್ತೇವೆ).
- "".join(password_list): ಶಫಲ್ ಮಾಡಿದ ಅಕ್ಷರಗಳ ಲಿಸ್ಟ್ ಅನ್ನು ಒಂದೇ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪರಿವ��್ತಿಸಿ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.
main() ಫಂಕ್ಷನ್:
- ಬಳಕೆದಾರರಿಂದ ಪಾಸ್‌ವರ್ಡ್‌ನ ಉದ್ದ ಮತ್ತು ಯಾವ ರೀತಿಯ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಬೇಕು ಎಂಬ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುತ್ತದೆ.
- .lower() == 'yes' ಬಳಸಿ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು (Yes, yes, YES ಇತ್ಯಾದಿ) ಬೂಲಿಯನ್ (True/False) ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ.
- generate_password ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾಲ್ ಮಾಡಿ, ಬಂದ ಫಲಿತಾಂಶವನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತದೆ.
- try-except ಬ್ಲಾಕ್ ಬಳಸಿ, ಬಳಕೆದಾರರು ಉದ್ದಕ್ಕಾಗಿ ಸಂಖ್ಯೆಯ ಬದಲು ಬೇರೆನಾದರೂ ನಮೂದಿಸಿದರೆ ಎರರ್ ಅನ್ನು ಹ್ಯಾಂಡಲ್ ಮಾಡುತ್ತದೆ.