이 프로젝트로 모든 Python 기초를 다루세요 | 퀴즈부터 비밀번호 관리자까지.

王林
풀어 주다: 2024-09-06 06:00:13
원래의
670명이 탐색했습니다.

Cover All Python Fundamentals with these rojects | From Quizzes to Password Manager.

Membuat projek ialah cara terbaik untuk mengambil apa yang anda pelajari dan melaksanakannya. Walaupun projek ini kelihatan mudah dan mudah, ia memainkan peranan penting dalam membina asas yang kukuh dalam pengaturcaraan Python. Saya telah mencipta projek ini untuk merangkumi kebanyakan asas dalam Python, memastikan sesiapa sahaja boleh mempelajari dan meningkatkan kemahiran pengekodan mereka melalui latihan praktikal.

1. Permainan Kuiz

Apakah itu? Permainan kuiz mudah di mana komputer bertanya soalan dan pemain menjawabnya.

Konsep yang digunakan:

  • Senarai dan tupel
  • Modul rawak
  • Gelung
  • Pernyataan bersyarat
  • Pengendalian input pengguna
  • Penjejakan skor

Cara ia berfungsi: Permainan bermula dengan mengalu-alukan pemain dan bertanya sama ada mereka mahu bermain. Ia kemudian membentangkan satu siri soalan rawak daripada senarai yang telah ditetapkan. Jawapan pemain disemak, dan markah mereka dikemas kini dengan sewajarnya. Permainan ini memberikan maklum balas pada setiap jawapan dan memaparkan markah akhir pada penghujungnya.

import random  # Import the random module for shuffling

print("Welcome to the Quiz Game")  # Print welcome message
wanna_play = input("Do you want to play the game (yes/no): ").lower()  # Ask if the user wants to play
if wanna_play != 'yes':  # If user does not want to play, quit
    quit()
print("Okay, then! Let's play")  # Print message to start the game

# Creating a list of tuples containing questions and answers 
question_answer_pairs = [
    ("What does CPU stand for?", "Central Processing Unit"),
    ("Which programming language is known as the 'mother of all languages'?", "C"),
    ("What does HTML stand for?", "HyperText Markup Language"),
    # ... (more questions)
]

# Shuffle the list of tuples to ensure random order
random.shuffle(question_answer_pairs)

score = 0

# Iterate through the shuffled list of tuples 
for question, correct_answer in question_answer_pairs:
    user_answer = input(f"{question} ").strip()  # Ask the question and get user input
    if user_answer.lower() == correct_answer.lower():  # Check if the answer is correct
        print("Correct answer")
        score += 1  # Increase score for a correct answer
    else:
        print(f"Incorrect answer. The correct answer is: {correct_answer}")
        score -= 1  # Decrease score for an incorrect answer
    print(f"Current Score: {score}")

# Print the final score
print(f"Quiz over! Your final score is {score}/{len(question_answer_pairs)}")
로그인 후 복사

2. Permainan Teka Nombor (Teka Komputer)

Apakah itu? Permainan meneka nombor di mana komputer cuba meneka nombor yang dipilih oleh pengguna.

Konsep yang digunakan:

  • Fungsi
  • Gelung
  • Pernyataan bersyarat
  • Pengendalian input pengguna
  • Algoritma carian binari

Cara ia berfungsi: Pengguna mentakrifkan julat dan memilih nombor dalam julat itu. Komputer kemudiannya menggunakan pendekatan carian binari untuk meneka nombor, dengan pengguna memberikan maklum balas sama ada tekaan itu terlalu tinggi, terlalu rendah atau betul. Permainan diteruskan sehingga komputer meneka dengan betul atau menentukan bahawa nombor itu berada di luar julat yang ditentukan.

def guess_number():
    """
    Function where the computer attempts to guess a number chosen by the user within a specified range.

    The user defines the lower and upper bounds of the range and provides a number for the computer to guess.
    The computer uses a binary search approach to guess the number and the user provides feedback to guide it.
    """
    # Get the lower bound of the range from the user
    low = int(input("Enter the lower range: "))
    # Get the upper bound of the range from the user
    high = int(input("Enter the higher range: "))

    # Check if the provided range is valid
    if low >= high:
        print("Invalid range. The higher range must be greater than the lower range.")
        return  # Exit the function if the range is invalid

    # Get the number from the user that the computer will attempt to guess
    Your_number = int(input(f"Enter your number for the computer to guess between {low} and {high}: "))

    # Check if the number entered by the user is within the specified range
    if Your_number < low or Your_number > high:
        print("The number you entered is out of the specified range.")
        return  # Exit the function if the number is out of the range

    # Initialize the computer's guess variable
    computer_guess = None

    # Loop until the computer guesses the correct number
    while computer_guess != Your_number:
        # Compute the computer's guess as the midpoint of the current range
        computer_guess = (low + high) // 2
        print(f"The computer guesses: {computer_guess}")

        # Get feedback from the user about the computer's guess
        feedback = input(f"Is {computer_guess} too low, too high, or correct? (Enter 'h' for higher, 'l' for lower, 'c' for correct): ").strip().lower()

        # Process the user's feedback to adjust the guessing range
        if feedback == 'c':
            if computer_guess == Your_number:
                print("The computer guessed your number correctly! Congrats!")
                return  # Exit the function once the correct number is guessed
            else:
                continue  
        elif feedback == 'h':
            high = computer_guess - 1  # If the guess is too high, lower the upper range
        elif feedback == 'l':
            low = computer_guess + 1  # If the guess is too low, increase the lower range
        else:
            print("Invalid feedback, please enter 'h', 'l', or 'c'.")  # Handle invalid feedback

# Call the function to start the guessing game
guess_number()
로그인 후 복사

3. Permainan Teka Nombor (Teka Pengguna)

Apakah itu? Permainan meneka nombor di mana pengguna cuba meneka nombor yang dijana secara rawak.

Konsep yang digunakan:

  • Fungsi
  • Modul rawak
  • Gelung
  • Pernyataan bersyarat
  • Pengendalian pengecualian
  • Pengesahan input pengguna

Cara ia berfungsi: Komputer menjana nombor rawak dalam julat yang ditentukan. Pengguna kemudian membuat tekaan, dan program memberikan maklum balas sama ada tekaan itu terlalu tinggi atau terlalu rendah. Permainan diteruskan sehingga pengguna meneka nombor yang betul atau memutuskan untuk berhenti.

import random  # Import the random module to use its functions for generating random numbers

def guess_random_number(number):
    """
    Function to allow the user to guess a random number between 1 and the specified `number`.
    This function generates a random integer between 1 and the provided `number` (inclusive).
    It then repeatedly prompts the user to guess the random number, providing feedback on whether
    the guess is too high or too low, until the correct number is guessed. The function handles
    invalid inputs by catching exceptions and informing the user to enter a valid integer.
    """
    # Generate a random number between 1 and the specified `number` (inclusive)
    random_number = random.randint(1, number)
    guess = None  # Initialize the variable `guess` to None before starting the loop

    # Loop until the user guesses the correct number
    while guess != random_number:
        try:
            # Prompt the user to enter a number between 1 and `number`
            guess = int(input(f"Enter a number between 1 and {number}: "))

            # Provide feedback based on whether the guess is too low or too high
            if guess < random_number:
                print("Too low, guess a greater number.")
            elif guess > random_number:
                print("Too high, guess a smaller number.")

        except ValueError:
            # Handle the case where the user inputs something that isn't an integer
            print("Invalid input. Please enter a valid integer.")

    # Congratulate the user once they guess the correct number
    print("You have guessed the random number correctly. Congrats!")

# Call the function with an upper limit of 10
guess_random_number(10)
로그인 후 복사

4. Permainan Hangman

Apakah itu? Permainan meneka perkataan klasik di mana pemain cuba meneka perkataan tersembunyi huruf demi huruf.

Konsep yang digunakan:

  • Mengimport modul
  • Pilihan rawak daripada senarai
  • Manipulasi rentetan
  • Gelung
  • Pernyataan bersyarat
  • Pemahaman senarai

Cara ia berfungsi: Permainan memilih perkataan rawak daripada senarai yang telah ditetapkan. Pemain kemudian meneka huruf satu demi satu. Tekaan yang betul mendedahkan kedudukan huruf dalam perkataan, manakala tekaan yang salah mengurangkan baki nyawa pemain. Permainan tamat apabila pemain meneka keseluruhan perkataan atau kehabisan nyawa.

import random
from word_list import words  # Import the words from word_list.py file

def hangman():
    random_word = random.choice(words)  # Generate the random word
    print(random_word)  # Print the chosen word for testing purposes; remove in production

    word_display = ["_"] * len(random_word)  # Create blank lines "_" equal to the length of the word
    guessed_letters = []  # Empty list to store the letters that have been guessed
    lives = 5  # Number of lives for the player

    print("Welcome to Hangman!")  # Print welcome statement
    print(" ".join(word_display))  # Display the current state of the word

    while lives > 0:  # The game continues to run as long as the player has more than 0 lives
        user_guess = input("Enter a single letter for your guess: ").lower()  # Ask the player to input a letter

        # Check whether the player entered a valid input
        if len(user_guess) != 1 or not user_guess.isalpha():
            print("Invalid input. Please enter a single letter.")
            continue

        # Check if the letter has already been guessed
        if user_guess in guessed_letters:
            print(f"You've already guessed '{user_guess}'. Try another guess.")
            continue

        # Add the guessed letter to the guessed_letters list
        guessed_letters.append(user_guess)

        # Check if the guessed letter is in the random_word
        if user_guess in random_word:
            # Update word_display with the correctly guessed letter
            for index, letter in enumerate(random_word):
                if letter == user_guess:
                    word_display[index] = user_guess
            print("Good guess!")
        else:
            lives -= 1  # Reduce the number of remaining lives by 1 for an incorrect guess
            print(f"Wrong guess! Remaining lives: {lives}")

        # Display the current state of the word
        print(" ".join(word_display))

        # Check if the player has guessed all letters
        if "_" not in word_display:
            print("Congratulations, you guessed the word!")
            break

    else:
        # This runs if no lives are left
        print(f"You have run out of lives. The word was: {random_word}")

hangman()  # Function to start the game
로그인 후 복사

5.Gunting Kertas Batu

Apakah itu? Permainan klasik "Batu, Kertas, Gunting" tempat pengguna bermain melawan komputer.

Konsep yang digunakan:

  • Gelung
  • Pernyataan bersyarat
  • Fungsi
  • Modul rawak
  • Pengendalian input pengguna

Cara ia berfungsi: Pengguna memilih sama ada batu, kertas atau gunting, manakala komputer juga memilih salah satu pilihan secara rawak. Program ini kemudian membandingkan pilihan, menentukan pemenang dan bertanya kepada pengguna jika mereka mahu bermain lagi.

import random  # Import the random module to generate random choices for the computer.

def playGame():
    while True:  # Infinite loop to keep the game running until the user decides to stop.
        # Ask the user to enter their choice and convert it to lowercase.
        user_choice = input("Enter 'r' for rock, 'p' for paper, 's' for scissors: ").strip().lower()

        # Check if the user input is valid (i.e., 'r', 'p', or 's').
        if user_choice not in ['r', 'p', 's']:
            print("Invalid Input. Please try again.")
            continue  # If the input is invalid, restart the loop.

        print(f"You chose {user_choice}")  # Display the user's choice.

        # Computer randomly picks one of the choices ('r', 'p', 's').
        computer_choice = random.choice(['r', 'p', 's'])
        print(f"The computer chose {computer_choice}")  # Display the computer's choice.

        # Check if the user's choice is the same as the computer's choice.
        if user_choice == computer_choice:
            print("It's a tie.")  # It's a tie if both choices are the same.
        elif _iswinner(user_choice, computer_choice):
            print("You won!")  # The user wins if their choice beats the computer's choice.
        else:
            print("You lost.")  # The user loses if the computer's choice beats theirs.

        # Ask the user if they want to play again.
        play_again = input("Do you want to play again? Enter 'yes' or 'no': ").strip().lower()

        # If the user doesn't enter 'yes', end the game.
        if play_again != 'yes':
            print("Thank you for playing!")  # Thank the user for playing.
            break  # Exit the loop and end the game.

def _iswinner(user, computer):
    # Determine if the user's choice beats the computer's choice.
    # Rock ('r') beats Scissors ('s'), Scissors ('s') beat Paper ('p'), Paper ('p') beats Rock ('r').
    if (user == "r" and computer == "s") or (user == "p" and computer == "r") or (user == "s" and computer == "p"):
        return True  # Return True if the user wins.

# Start the game by calling the playGame function.
playGame()
로그인 후 복사

6. 2 Pengguna Tick Tack Toe

Apa itu Tic-Tac-Toe ialah permainan dua pemain klasik di mana pemain bergilir-gilir menandakan ruang pada grid 3x3. Matlamatnya adalah untuk menjadi orang pertama yang mendapat tiga markah mereka berturut-turut, sama ada secara mendatar, menegak atau menyerong. Permainan berakhir apabila seorang pemain mencapai ini, atau apabila semua ruang pada grid diisi tanpa pemenang, menghasilkan keputusan seri.

*Konsep yang digunakan: *

  • Definisi dan Panggilan Fungsi
  • Struktur Data (Senarai 2D)
  • Gelung (untuk, sementara)
  • Pernyataan Bersyarat (jika, lain)
  • Pengendalian dan Pengesahan Input
  • Pengurusan Negeri Permainan
  • Pemformatan Rentetan
  • Pengendalian Pengecualian
def print_board(board):
    """Prints the game board in a structured format with borders."""
    print("\n+---+---+---+")  # Print the top border of the board
    for row in board:
        # print each row with cell values separated by borders
        print("| " + " | ".join(row) + " |")
        # print the border after each row
        print("+---+---+---+")

def check_winner(board):
    """Checks for a winner or a draw."""
    # define all possible winning lines: rows, columns, and diagonals
    lines = [
        [board[0][0], board[0][1], board[0][2]],  # Row 1
        [board[1][0], board[1][1], board[1][2]],  # Row 2
        [board[2][0], board[2][1], board[2][2]],  # Row 3
        [board[0][0], board[1][0], board[2][0]],  # Column 1
        [board[0][1], board[1][1], board[2][1]],  # Column 2
        [board[0][2], board[1][2], board[2][2]],  # Column 3
        [board[0][0], board[1][1], board[2][2]],  # Diagonal from top-left to bottom-right
        [board[0][2], board[1][1], board[2][0]]   # Diagonal from top-right to bottom-left
    ]

    # Check each line to see if all three cells are the same and not empty
    for line in lines:
        if line[0] == line[1] == line[2] and line[0] != ' ':
            return line[0]  # Return the player ('X' or 'O') who has won

    # Check if all cells are filled and there is no winner
    if all(cell != ' ' for row in board for cell in row):
        return 'Draw'  # Return 'Draw' if the board is full and no winner

    return None  # Return None if no winner and the game is not a draw

def main():
    """Main function to play the Tic Tac Toe game."""
    # Initialize the board with empty spaces
    board = [[' ' for _ in range(3)] for _ in range(3)]
    current_player = 'X'  # Start with player 'X'

    while True:
        print_board(board)  # Print the current state of the board

        try:
            # Prompt the current player for their move
            move = input(f"Player {current_player}, enter your move (1-9): ")
            move = int(move)  # Convert the input to an integer

            # Check if the move is valid (between 1 and 9)
            if move < 1 or move > 9:
                print("Invalid move, try again.")
                continue  # Ask for a new move

        except ValueError:
            # Handle cases where the input is not an integer
            print("Invalid move, try again.")
            continue  # Ask for a new move

        # Convert the move number to board coordinates (row, col)
        row, col = divmod(move - 1, 3)

        # Check if the cell is already occupied
        if board[row][col] != ' ':
            print("Cell already occupied. Choose a different cell.")
            continue  # Ask for a new move

        # Place the current player's mark on the board
        board[row][col] = current_player

        # Check if there is a winner or if the game is a draw
        winner = check_winner(board)

        if winner:
            print_board(board)  # Print the final board state
            if winner == 'Draw':
                print("The game is a draw!")
            else:
                print(f"Player {winner} wins!")  # Announce the winner
            break  # End the game

        # Switch players
        current_player = 'O' if current_player == 'X' else 'X'

if __name__ == "__main__":
    main()  # Start the game
로그인 후 복사

7. Pengurus Kata Laluan

Apakah itu? Pengurus kata laluan mudah yang membolehkan pengguna menyimpan dan mendapatkan semula kata laluan yang disulitkan.

Concepts used:

  • File I/O operations
  • Encryption using the cryptography library
  • Functions
  • Exception handling
  • User input handling
  • Loops

How it works: The program uses the Fernet symmetric encryption from the cryptography library to securely store passwords. Users can add new passwords or view existing ones. Passwords are stored in an encrypted format in a text file, and decrypted when viewed.

from cryptography.fernet import Fernet

# The write_key function generates an encryption key and saves it to a file.
# It's currently commented out, but you need to run it once to create the 'key.key' file.
'''
def write_key():
    key = Fernet.generate_key()
    with open("key.key", "wb") as key_file:
        key_file.write(key)
'''

def load_key():
    """This function loads the encryption key from the 'key.key' file."""
    file = open("key.key", "rb")
    key = file.read()
    file.close()
    return key

# Load the key and create a Fernet object
key = load_key()
fer = Fernet(key)

def view():
    """Function to view stored passwords in the 'passwords.txt' file"""
    with open('passwords.txt', 'r') as f:
        for line in f.readlines():
            data = line.rstrip()
            user, passw = data.split("|")
            decrypted_password = fer.decrypt(passw.encode()).decode()
            print("User:", user, "| Password:", decrypted_password)

def add():
    """Function to add new account names and passwords to the 'passwords.txt' file"""
    name = input('Account Name: ')
    pwd = input("Password: ")
    with open('passwords.txt', 'a') as f:
        encrypted_password = fer.encrypt(pwd.encode()).decode()
        f.write(name + "|" + encrypted_password + "\n")

# Main loop to ask the user what they want to do: view passwords, add new passwords, or quit
while True:
    mode = input(
        "Would you like to add a new password or view existing ones (view, add), press q to quit? ").lower()

    if mode == "q":
        break
    if mode == "view":
        view()
    elif mode == "add":
        add()
    else:
        print("Invalid mode.")
        continue
로그인 후 복사

Thanks for stopping and reading the blog.
Github Repo : https://github.com/iamdipsan/Python-Projects

위 내용은 이 프로젝트로 모든 Python 기초를 다루세요 | 퀴즈부터 비밀번호 관리자까지.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

원천:dev.to
본 웹사이트의 성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
인기 튜토리얼
더>
최신 다운로드
더>
웹 효과
웹사이트 소스 코드
웹사이트 자료
프론트엔드 템플릿
회사 소개 부인 성명 Sitemap
PHP 중국어 웹사이트:공공복지 온라인 PHP 교육,PHP 학습자의 빠른 성장을 도와주세요!