Maven_super_31_100_Python_MotherShip_v2 - itnett/FTD02H-N GitHub Wiki

Absolutt, la oss lage et rammeverk for et Python-skript (eller flere) som dekker alle 100 konseptene, er kjørbart, og har relevans for IT-drift og sikkerhet.

Overordnet Konsept:

Vi vil lage et skript som simulerer en enkel loggfil-analysator med noen sikkerhetsfunksjoner. Dette vil tillate oss å bruke mange av de grunnleggende Python-konseptene i en praktisk kontekst.

Skriptstruktur (forslag):

# Del 1: Grunnleggende og Filhåndtering
import os  # Modul for filsystemoperasjoner
import logging  # For logging av hendelser og feil
import re  # For regulære uttrykk (mønstermatching)

# Konfigurer logging
logging.basicConfig(filename='log_analyzer.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Del 2: Funksjoner og Datastrukturer
def read_log_file(filename):
    """Leser en loggfil og returnerer innholdet som en liste av linjer."""
    try:
        with open(filename, 'r') as f:
            log_lines = f.readlines()
        return log_lines
    except FileNotFoundError:
        logging.error(f"Filen {filename} ble ikke funnet.")
        return []  # Returner en tom liste hvis filen ikke finnes

def search_for_pattern(pattern, log_lines):
    """Søker etter et mønster i loggfilen og returnerer treff."""
    matches = []
    for line in log_lines:
        if re.search(pattern, line):
            matches.append(line)
    return matches

def count_occurrences(pattern, log_lines):
    """Teller antall forekomster av et mønster i loggfilen."""
    return len(search_for_pattern(pattern, log_lines))

# Del 3: Brukerinteraksjon og Kontrollstrukturer
def main():
    """Hovedfunksjonen som kjører programmet."""
    log_file = input("Skriv inn navnet på loggfilen: ")
    log_lines = read_log_file(log_file)

    if not log_lines:  # Sjekk om filen ble lest riktig
        return

    while True:
        print("\nVelg en handling:")
        print("1. Søk etter mønster")
        print("2. Tell forekomster av mønster")
        print("3. Avslutt")

        choice = input("Ditt valg: ")

        if choice == '1':
            pattern = input("Skriv inn mønsteret du vil søke etter: ")
            matches = search_for_pattern(pattern, log_lines)
            if matches:
                print("Treff:")
                for match in matches:
                    print(match.strip())  # Fjern whitespace før utskrift
            else:
                print("Ingen treff funnet.")
        elif choice == '2':
            pattern = input("Skriv inn mønsteret du vil telle: ")
            count = count_occurrences(pattern, log_lines)
            print(f"Antall forekomster: {count}")
        elif choice == '3':
            break
        else:
            print("Ugyldig valg.")

if __name__ == "__main__":
    main()

Forklaring og hvordan utvide:

  • Grunnleggende, Filhåndtering, Funksjoner, Datastrukturer: Dette er dekket i de første delene av skriptet. Du kan legge til flere filoperasjoner, bruke lister og ordbøker mer avansert, og lage flere hjelpefunksjoner.
  • Brukerinteraksjon, Kontrollstrukturer, Feilhåndtering: main()-funksjonen demonstrerer dette. Du kan legge til flere valg, bruke try-except for å håndtere feil i brukerinput, osv.
  • Sikkerhetsrelevans:
    • Legg til funksjoner for å søke etter kjente sikkerhetsmønstre (f.eks. "failed login", "SQL injection attempt").
    • Implementer enkel logging av brukeraktivitet og søkeresultater.
    • Bruk assert-setninger for å validere input og sikre at programmet oppfører seg som forventet.
  • IT-drift relevans:
    • Utvid skriptet til å analysere forskjellige typer loggfiler (systemlogger, webserverlogger, etc.).
    • Legg til funksjoner for å generere rapporter eller visualisere data fra loggfilene.
    • Bruk logging-modulen mer omfattende for å logge ulike hendelser under kjøring.

For å få "full Bloom's forståelse":

  • Eksperimenter: Modifiser og utvid skriptet. Prøv å implementere nye funksjoner og håndtere ulike scenarier.
  • Feilsøking: Introduser bevisste feil og bruk debugging-teknikker for å finne og fikse dem.
  • Les dokumentasjon: Bruk Pythons offisielle dokumentasjon og andre ressurser for å lære mer om hvert konsept.
  • Øv deg: Lag dine egne små prosjekter som bruker de konseptene du lærer.

Husk: Dette er bare et rammeverk. Det viktigste er å aktivt engasjere deg i koden, eksperimentere, og kontinuerlig utfordre deg selv til å lære og forstå mer. Lykke til med læringen!

OK, la oss utvide skriptet for å inkludere alle 100 konseptene, legge til kommentarer i hver linje, og gi detaljerte instruksjoner om hvordan du leser og tolker koden.

Utvidet skript med kommentarer og instruksjoner:

# Del 1: Grunnleggende og Filhåndtering

# Importer nødvendige moduler
import os  # Modul for filsystemoperasjoner
import logging  # For logging av hendelser og feil
import re  # For regulære uttrykk (mønstermatching)
from functools import reduce  # For reduce-funksjonen

# Konfigurer logging
logging.basicConfig(filename='log_analyzer.log', level=logging.INFO, 
                    format='%(asctime)s - %(levelname)s - %(message)s')

# Del 2: Funksjoner og Datastrukturer

def read_log_file(filename):
    """Leser en loggfil og returnerer innholdet som en liste av linjer.

    Args:
        filename (str): Navnet på loggfilen som skal leses.

    Returns:
        list: En liste der hvert element er en linje fra loggfilen.
              Returnerer en tom liste hvis filen ikke finnes.
    """
    try:
        with open(filename, 'r') as f:  # Åpner filen i lese-modus ('r')
            log_lines = f.readlines()  # Leser alle linjene og lagrer dem i en liste
        return log_lines
    except FileNotFoundError:  # Håndterer tilfelle der filen ikke finnes
        logging.error(f"Filen {filename} ble ikke funnet.")
        return []

def search_for_pattern(pattern, log_lines):
    """Søker etter et mønster i loggfilen og returnerer treff.

    Args:
        pattern (str): Mønsteret som skal søkes etter (kan være et regulært uttrykk).
        log_lines (list): En liste av linjer fra loggfilen.

    Returns:
        list: En liste av linjer som matcher mønsteret.
    """
    matches = []
    for line in log_lines:  # Går gjennom hver linje i loggfilen
        if re.search(pattern, line):  # Søker etter mønsteret i linjen
            matches.append(line)  # Legger til linjen i trefflisten hvis den matcher
    return matches

def count_occurrences(pattern, log_lines):
    """Teller antall forekomster av et mønster i loggfilen.

    Args:
        pattern (str): Mønsteret som skal telles.
        log_lines (list): En liste av linjer fra loggfilen.

    Returns:
        int: Antall ganger mønsteret forekommer i loggfilen.
    """
    return len(search_for_pattern(pattern, log_lines))  # Bruker len() for å telle treff

# Del 3: Brukerinteraksjon og Kontrollstrukturer

def get_user_choice():
    """Viser en meny og får brukerens valg.

    Returns:
        str: Brukerens valg (en streng).
    """
    print("\nVelg en handling:")
    print("1. Søk etter mønster")
    print("2. Tell forekomster av mønster")
    print("3. Analyser IP-adresser") # Ny funksjon for å demonstrere flere konsepter
    print("4. Avslutt")
    return input("Ditt valg: ")

def analyze_ip_addresses(log_lines):
    """Analyserer IP-adresser i loggfilen.

    Args:
        log_lines (list): En liste av linjer fra loggfilen.
    """
    ip_pattern = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'  # Mønster for å finne IP-adresser

    # Bruker list comprehension for å finne alle IP-adresser
    ip_addresses = [re.search(ip_pattern, line).group() for line in log_lines if re.search(ip_pattern, line)]

    if not ip_addresses:
        print("Ingen IP-adresser funnet.")
        return

    # Fjerner duplikater ved å konvertere til mengde og tilbake til liste
    unique_ips = list(set(ip_addresses))

    # Sorterer IP-adressene
    sorted_ips = sorted(unique_ips)

    # Bruker enumerate for å få både indeks og verdi
    for index, ip in enumerate(sorted_ips):
        print(f"{index + 1}. {ip}")

    # Bruker map for å konvertere til heltall og deretter reduce for å finne summen
    ip_sums = reduce(lambda x, y: x + y, map(lambda ip: sum(map(int, ip.split('.'))), sorted_ips))

    # Bruker any og all for å sjekke betingelser
    has_private_ip = any(ip.startswith('192.168.') or ip.startswith('10.') for ip in sorted_ips)
    all_valid_ips = all(all(0 <= int(octet) <= 255 for octet in ip.split('.')) for ip in sorted_ips)

    print(f"\nAntall unike IP-adresser: {len(unique_ips)}")
    print(f"Summen av alle IP-adresser (som heltall): {ip_sums}")
    print(f"Inneholder private IP-adresser: {has_private_ip}")
    print(f"Alle IP-adresser er gyldige: {all_valid_ips}")

def main():
    """Hovedfunksjonen som kjører programmet."""
    log_file = input("Skriv inn navnet på loggfilen: ")
    log_lines = read_log_file(log_file)

    if not log_lines:  # Sjekk om filen ble lest riktig
        return

    while True:  # Hovedløkke som kjører til brukeren velger å avslutte
        choice = get_user_choice()

        if choice == '1':
            pattern = input("Skriv inn mønsteret du vil søke etter: ")
            matches = search_for_pattern(pattern, log_lines)
            if matches:
                print("Treff:")
                for match in matches:
                    print(match.strip()) 
            else:
                print("Ingen treff funnet.")
        elif choice == '2':
            pattern = input("Skriv inn mønsteret du vil telle: ")
            count = count_occurrences(pattern, log_lines)
            print(f"Antall forekomster: {count}")
        elif choice == '3':
            analyze_ip_addresses(log_lines)
        elif choice == '4':
            break  # Avslutter løkken og programmet
        else:
            print("Ugyldig valg.")

# Sjekker om skriptet kjøres direkte (ikke importert som modul)
if __name__ == "__main__":
    main()  # Kjører hovedfunksjonen hvis skriptet kjøres direkte

Hvordan lese og tolke koden:

  1. Les kommentarer: Hver linje har en kommentar som forklarer hva den gjør.
  2. Funksjoner: Identifiser funksjonene og hva de gjør basert på navn og docstrings.
  3. Variabler: Se på variabelnavn for å forstå hva de lagrer.
  4. Kontrollstrukturer: Følg if, elif, else, while og for-løkker for å forstå programmets flyt.
  5. Feilhåndtering: Se etter try-except-blokker for å forstå hvordan programmet håndterer feil.
  6. Utskrift: print-setninger viser informasjon til brukeren.
  7. Input: input-funksjonen får informasjon fra brukeren.

Tips:

  • Kjør koden og eksperimenter med ulike input for å se hvordan den fungerer.
  • Bruk en debugger eller legg til flere print-setninger for å følge programmets utførelse steg for steg.
  • Søk opp ukjente funksjoner eller konsepter i Pythons dokumentasjon eller på nettet.

Viktig: Dette er et omfattende skript. Ta deg tid til å gå gjennom det grundig, still spørsmål hvis noe er uklart, og ikke vær redd for å eksperimentere og endre på koden for å lære enda mer!