Python für Information Science (kostenloser 7-Tage-Mini-Course)

Bild von Editor | Chatgpt

# Einführung

Willkommen zu Python für Information Science, ein kostenloser 7-Tage-Mini-Kurs Für Anfänger! Wenn Sie mit Information Science beginnen oder grundlegende Python-Fähigkeiten erlernen möchten, ist dieser anfängerfreundliche Kurs für Sie. In den nächsten sieben Tagen lernen Sie, wie Sie mit nur Kernpython an Datenaufgaben arbeiten.

Sie werden lernen, wie man:

• Arbeiten Sie mit grundlegenden Python -Datenstrukturen
• Reinigen und vorbereiten Sie unordentliche Textdaten
• Fassen Sie Daten mit Wörterbüchern zusammen (wie Sie es in SQL oder Excel tun)
• Schreiben Sie wiederverwendbare Funktionen, die Ihren Code ordentlich und effizient halten
• Behandeln Sie Fehler anmutig, damit Ihre Skripte nicht auf unordentlichen Eingabedaten abstürzen
• Und schließlich erstellen Sie ein einfaches Datenprofiling -Device, um einen CSV -Datensatz zu inspizieren

Fangen wir an!

🔗 Hyperlink zum Code auf GitHub

# Tag 1: Variablen, Datentypen und Datei I/O

In der Information Science beginnt alles mit Rohdaten: Umfrageantworten, Protokolle, Tabellenkalkulationen, Formulare, abgekratzte Web sites usw. Bevor Sie etwas modellieren oder analysieren können, müssen Sie:

• Laden Sie die Daten
• Verstehe seine Type und Typen
• Anfangen zu reinigen oder zu inspizieren

Heute werden Sie lernen:

• Die grundlegenden Python -Datentypen
• So lesen und schreiben Sie RAW .txt -Dateien

// 1. Variablen

In Python ist eine Variable ein benannter Verweis auf einen Wert. In Datenbegriffen können Sie sie als Felder, Spalten oder Metadaten betrachten.

filename = "responses.txt"
survey_name = "Q3 Buyer Suggestions"
max_entries = 100

// 2. Datentypen, die Sie häufig verwenden,

Mach dir noch keine Sorgen um dunkle Typen. Sie werden meistens Folgendes verwenden:

Wenn Sie wissen, wann Sie mit jedem zu tun haben – und wie Sie sie überprüfen oder konvertieren – ist die Datenreinigung Schritt Null.

// 3. Dateieingabe: Rohdaten lesen

Die meisten realen Daten leben in .txt-, .csv- oder .log-Dateien. Sie müssen sie oft Linie für Linie laden, nicht alle gleichzeitig (besonders wenn sie groß).

Nehmen wir an, Sie haben eine Datei aufgerufen responses.txt:

So lesen Sie es:

with open("responses.txt", "r") as file:
    traces = file.readlines()

for i, line in enumerate(traces):
    cleaned = line.strip()  # removes n and areas
    print(f"{i + 1}: {cleaned}")

Ausgabe:

1: Sure
2: No
3: Sure
4: Perhaps
5: No

// 4. Dateiausgabe: Verarbeitete Daten schreiben

Nehmen wir an, Sie möchten nur „Ja“ Antworten auf eine neue Datei speichern:

with open("responses.txt", "r") as infile:
    traces = infile.readlines()

yes_responses = ()

for line in traces:
    if line.strip().decrease() == "sure":
        yes_responses.append(line.strip())

with open("yes_only.txt", "w") as outfile:
    for merchandise in yes_responses:
        outfile.write(merchandise + "n")

Dies ist eine tremendous einfache Model einer Filter-Remodel-Save-Pipeline, ein Konzept, das täglich in der Datenvorverarbeitung verwendet wird.

// ⏭️ Übung: Schreiben Sie Ihr erstes Datenskript

Erstellen Sie eine Datei aufgerufen survey.txt und kopieren Sie in den folgenden Zeilen:

Schreiben Sie nun ein Python -Skript, das:

1. Liest die Datei
2. Zählt, wie oft „Ja“ erscheint (Fall-unempfindlich). Sie werden lernen, später im Textual content mit Saiten zu arbeiten. Aber probiere es aus!
3. Druckt die Anzahl
4. Schreibt eine saubere Model der Daten (aktiviert, ohne Weißespace) zu cleaned_survey.txt

# Tag 2: Grundlegende Python -Datenstrukturen

Bei der Datenwissenschaft geht es darum, Daten zu organisieren und zu strukturieren, damit sie gereinigt, analysiert oder modelliert werden können. Heute lernen Sie die vier wesentlichen Datenstrukturen in Core Python und wie Sie sie für tatsächliche Datenaufgaben verwenden:

• Liste: Für Reihensequenzen
• Tupel: Für Aufzeichnungen mit festen Positionen
• DICT: Für beschriftete Daten (wie Spalten)
• SET: Für die Verfolgung der einzigartigen Werte

// 1. Liste: Für Sequenzen von Datenzeilen

Pay attention sind die flexibelste und häufigste Struktur, die für die Darstellung geeignet ist:

• Eine Wertespalte
• Eine Sammlung von Aufzeichnungen
• Ein Datensatz mit unbekannter Größe

Beispiel: Lesen Sie Werte aus einer Datei in eine Liste.

with open("scores.txt", "r") as file:
    scores = (float(line.strip()) for line in file)

print(scores)

Dies druckt:

Sie können jetzt:

common = sum(scores) / len(scores)
print(f"Common rating: {common:.2f}")

Ausgabe:

// 2. Tupel: Für Feststrukturdatensätze

Tupel sind wie Pay attention, aber unveränderlich und am besten für Zeilen mit bekannter Struktur, z. B. (Title, Alter) verwendet.

Beispiel: Lesen Sie eine Datei mit Namen und Altersdateien.
Angenommen, wir haben Folgendes individuals.txt:

Alice, 34
Bob, 29
Eve, 41

Lassen Sie uns nun im Inhalt der Datei lesen:

with open("individuals.txt", "r") as file:
    information = ()
    for line in file:
        title, age = line.strip().cut up(",")
        information.append((title.strip(), int(age.strip())))

Jetzt können Sie mit Place auf Felder zugreifen:

for individual in information:
    title, age = individual
    if age > 30:
        print(f"{title} is over 30.")

// 3. Diktat: Für gekennzeichnete Daten (wie Spalten)

Wörterbücher speichern Schlüsselwertpaare, das am nächsten in der Kernpython in einer Tabellenreihe mit benannten Spalten.

Beispiel: Konvertieren Sie jede Particular person -Aufzeichnung in ein Diktat:

individuals = ()

with open("individuals.txt", "r") as file:
    for line in file:
        title, age = line.strip().cut up(",")
        individual = {
            "title": title.strip(),
            "age": int(age.strip())
        }
        individuals.append(individual)

Jetzt sind Ihre Daten viel lesbarer und flexibler:

for individual in individuals:
    if individual("age") < 60:
        print(f"{individual('title')} is probably a working skilled.")

// 4.. Set: Für Einzigartigkeit und schnelle Mitgliedschaftskontrollen

Legt automatisch Duplikate ein. Units sind additionally großartig für:

• Zählen einzigartige Kategorien
• Überprüfen Sie, ob zuvor ein Wert gesehen wurde
• Verfolgung verschiedener Werte ohne Ordnung verfolgen

Beispiel: Suchen Sie aus einer Datei mit E -Mails alle eindeutigen Domänen.

domains = set()

with open("emails.txt", "r") as file:
    for line in file:
        e-mail = line.strip().decrease()
        if "@" in e-mail:
            area = e-mail.cut up("@")(1)
            domains.add(area)

print(domains) 

Ausgabe:

{'gmail.com', 'yahoo.com', 'instance.org'}

// ⏭️ Übung: Codieren Sie einen Mini -Dateninspektor

Erstellen Sie eine Datei aufgerufen dataset.txt mit dem folgenden Inhalt:

Schreiben Sie nun ein Python -Skript, das:

1. Liest jede Zeile und speichert sie als Wörterbuch mit Schlüsseln: Title, Alter, Rolle
2. Zählt, wie viele Menschen in jeder Rolle sind (verwenden Sie ein Wörterbuch) und die Anzahl der eindeutigen Altersgruppen (verwenden Sie einen Satz)

# Tag 3: Mit Saiten arbeiten

Textzeichenfolgen befinden sich überall in den meisten realen Datensätzen-Umfrageantworten, Benutzer-BIOS, Jobtitel, Produktbewertungen, E-Mails und mehr-, aber sie sind auch inkonsistent und unvorhersehbar.

Heute lernen Sie:

• Reinigen und standardisieren Sie Rohtext
• Informationen aus Strings extrahieren
• Erstellen Sie einfache textbasierte Funktionen (die Artwork, die Sie zum Filtern oder Modellieren verwenden können)

// 1. Grundreinigung

Nehmen wir an, Sie erhalten diese rohe Liste von Jobtiteln von einem CSV:

titles = (
    "  Information Scientistn",
    "knowledge scientist",
    "Senior Information Scientist ",
    "DATA scientist",
    "Information engineer",
    "Information Scientist"
)

Dein Job? Normalisieren Sie es.

cleaned = (title.strip().decrease() for title in titles)

Jetzt ist alles Kleinbuchstaben und weißespacefrei.

Ausgabe:

('knowledge scientist', 'knowledge scientist', 'senior knowledge scientist', 'knowledge scientist', 'knowledge engineer', 'knowledge scientist')

// 2. Standardisierungswerte

Nehmen wir an, Sie sind nur daran interessiert, Datenwissenschaftler zu identifizieren.

standardized = ()

for title in cleaned:
    if "knowledge scientist" in title:
        standardized.append("knowledge scientist")
    else:
        standardized.append(title)

// 3. Zählen Sie Wörter, prüfen Sie Muster

Nützliche Textmerkmale:

• Anzahl der Wörter
• Ob eine Zeichenfolge ein Schlüsselwort enthält
• Ob eine Zeichenfolge eine Nummer oder eine E -Mail ist

Beispiel:

textual content = " The value is $5,000!  "

# Clear up
clear = textual content.strip().decrease().exchange("$", "").exchange(",", "").exchange("!", "")
print(clear)  

# Phrase rely
word_count = len(clear.cut up())

# Comprises digit
has_number = any(char.isdigit() for char in clear)

print(word_count)
print(has_number)

Ausgabe:

"the value is 5000"
4
True

// 4. Teile teilen und extrahieren

Nehmen wir das E -Mail -Beispiel:

e-mail = "  Alice.Johnson@Instance.com  "
e-mail = e-mail.strip().decrease()

username, area = e-mail.cut up("@")

print(f"Person: {username}, Area: {area}")

Dies druckt:

Person: alice.johnson, Area: instance.com

Diese Artwork der Extraktion wird in der Benutzerverhaltensanalyse, der Spam -Erkennung und dergleichen verwendet.

// 5. Erkennen bestimmter Textmuster

Sie benötigen keine regelmäßigen Ausdrücke für grundlegende Musterprüfungen.

Beispiel: Überprüfen Sie, ob jemand „Python“ in einer freien Textantwort erwähnt hat:

remark = "I am studying Python and SQL for knowledge jobs."

if "python" in remark.decrease():
    print("Talked about Python")

// ⏭️ Übung: Clear Survey Kommentare

Erstellen Sie eine Datei aufgerufen feedback.txt mit den folgenden Zeilen:

Nice course! Cherished the pacing.
Not sufficient Python examples.
Too primary for knowledgeable customers.
python is precisely what I wanted!
Would really like extra SQL content material.
Wonderful – very beginner-friendly.

Schreiben Sie nun ein Python -Skript, das:

1. Reinigt jeden Kommentar (Streifen, Kleinbuchstaben, Interpunktion entfernen)
2. Druckt die Gesamtzahl der Kommentare, wie viele „Python“ und die durchschnittliche Wortzahl professional Kommentar erwähnen

# Tag 4: Gruppe, Depend & Fassungsgruppe mit Wörterbüchern

Sie haben DICT verwendet, um beschriftete Datensätze zu speichern. Heute werden Sie ein Degree tiefer gehen: Verwenden von Wörterbüchern, um Daten zu gruppieren, zu zählen und zusammenzufassen – genau wie eine Pivot -Tabelle oder Gruppe in SQL.

// 1. gruppieren nach einem Feld

Nehmen wir an, Sie haben diese Daten.

knowledge = (
    {"title": "Alice", "metropolis": "London"},
    {"title": "Bob", "metropolis": "Paris"},
    {"title": "Eve", "metropolis": "London"},
    {"title": "John", "metropolis": "New York"},
    {"title": "Dana", "metropolis": "Paris"},
)

Ziel: Zählen Sie, wie viele Menschen in jeder Stadt sind.

city_counts = {}

for individual in knowledge:
    metropolis = individual("metropolis")
    if metropolis not in city_counts:
        city_counts(metropolis) = 1
    else:
        city_counts(metropolis) += 1

print(city_counts)

Ausgabe:

{'London': 2, 'Paris': 2, 'New York': 1}

// 2. Summieren eines Feldes nach Kategorie

Nehmen wir jetzt an, wir haben:

salaries = (
    {"position": "Engineer", "wage": 75000},
    {"position": "Analyst", "wage": 62000},
    {"position": "Engineer", "wage": 80000},
    {"position": "Supervisor", "wage": 95000},
    {"position": "Analyst", "wage": 64000},
)

Ziel: Berechnen Sie das Gesamt- und Durchschnittsgehalt professional Rolle.

totals = {}
counts = {}

for individual in salaries:
    position = individual("position")
    wage = individual("wage")
    
    totals(position) = totals.get(position, 0) + wage
    counts(position) = counts.get(position, 0) + 1

averages = {position: totals(position) / counts(position) for position in totals}

print(averages)

Ausgabe:

{'Engineer': 77500.0, 'Analyst': 63000.0, 'Supervisor': 95000.0}

// 3. Frequenztabelle (Moduserkennung)

Finden Sie das häufigste Alter in einem Datensatz:

ages = (29, 34, 29, 41, 34, 29)

freq = {}

for age in ages:
    freq(age) = freq.get(age, 0) + 1

most_common = max(freq.objects(), key=lambda x: x(1))

print(f"Most typical age: {most_common(0)} (seems {most_common(1)} instances)")

Ausgabe:

Most typical age: 29 (seems 3 instances)

// ⏭️ Übung: Analysieren Sie den Mitarbeiterdatensatz

Eine Datei erstellen workers.txt mit dem folgenden Inhalt:

Alice,London,Engineer,75000
Bob,Paris,Analyst,62000
Eve,London,Engineer,80000
John,New York,Supervisor,95000
Dana,Paris,Analyst,64000

Schreiben Sie ein Python -Skript, das:

1. Lädt die Daten in eine Liste von Wörterbüchern
2. Druckt die Anzahl der Mitarbeiter professional Stadt und das durchschnittliche Gehalt professional Rolle

# Tag 5: Schreibfunktionen

Sie haben Code geschrieben, der Daten geladen, reinigt, filtert und zusammenfasst. Jetzt verpacken Sie diese Logik in Funktionen, damit Sie:

• Verwenden Sie Ihren Code wieder
• Verarbeitungspipelines erstellen
• Halten Sie Skripte lesbar und prüfbar

// 1. Reinigen von Texteingängen

Schreiben wir eine Funktion, um die grundlegende Textreinigung auszuführen:

def clean_text(textual content):
    return textual content.strip().decrease().exchange(",", "").exchange("$", "")

Jetzt können Sie dies auf jedes Feld anwenden, das Sie aus einer Datei lesen.

// 2. Erstellen von Zeilenaufzeichnungen

Als nächstes finden Sie hier eine einfache Funktion, um jede Zeile in eine Datei zu analysieren und Datensatz zu erstellen:

def parse_row(line):
    components = line.strip().cut up(",")
    return {
        "title": components(0),
        "metropolis": components(1),
        "position": components(2),
        "wage": int(components(3))
    }

Jetzt wird Ihre Datei geladen:

with open("workers.txt") as file:
    rows = (parse_row(line) for line in file)

// 3.. Aggregationshelfer

Bisher haben Sie Durchschnittswerte und die Anzahl der Ereignisse berechnet. Schreiben wir einige grundlegende Helferfunktionen für dasselbe:

def common(values):
    return sum(values) / len(values) if values else 0

def count_by_key(knowledge, key):
    counts = {}
    for merchandise in knowledge:
        okay = merchandise(key)
        counts(okay) = counts.get(okay, 0) + 1
    return counts

// ⏭️ Übung: Modularisieren Sie frühere Arbeiten

Refactor die gestrige Lösung in wiederverwendbare Funktionen:

• load_data(filename)
• average_salary_by_role(knowledge)
• count_by_city(knowledge)

Verwenden Sie sie dann in einem Skript, das die gleiche Ausgabe wie Tag 4 druckt.

# Tag 6: Lesen, Schreiben und grundlegende Fehlerbehandlung

Datendateien sind häufig unvollständig, beschädigt und fehlformiert. Wie gehst du mit ihnen um?

Heute werden Sie lernen:

• So lesen und schreiben Sie strukturierte Dateien
• Wie man anmutig Fehler umgeht
• So überspringen oder protokollieren Sie schlechte Zeilen, ohne zu stürzen

// 1. Safer Datei lesen

Was passiert, wenn Sie versuchen, eine Datei zu lesen, die es nicht gibt? So „versuchen“ Sie „versuchen“, die Datei zu öffnen und „FilenotFoundError“ zu fangen, wenn die Datei nicht vorhanden ist.

strive:
    with open("workers.txt") as file:
        traces = file.readlines()
besides FileNotFoundError:
    print("Error: File not discovered.")
    traces = ()

// 2.. Mit schlechten Reihen anmutig umgehen

Versuchen wir nun, schlechte Zeilen zu überspringen und nur die vollständigen Zeilen zu verarbeiten.

information = ()

for line in traces:
    strive:
        components = line.strip().cut up(",")
        if len(components) != 4:
            increase ValueError("Incorrect variety of fields")
        report = {
            "title": components(0),
            "metropolis": components(1),
            "position": components(2),
            "wage": int(components(3))
        }
        information.append(report)
    besides Exception as e:
        print(f"Skipping dangerous line: {line.strip()} ({e})")

// 3.. Schreiben Sie gereinigte Daten in eine Datei

Lassen Sie uns schließlich die gereinigten Daten in eine Datei schreiben.

with open("cleaned_employees.txt", "w") as out:
    for r in information:
        out.write(f"{r('title')},{r('metropolis')},{r('position')},{r('wage')}n")

// ⏭️ Übung: Machen Sie einen fehlertoleranten Lader

Erstellen Sie eine Datei RAW_EMPOTEES.txt mit ein paar unvollständigen oder unordentlichen Zeilen wie:

Alice,London,Engineer,75000
Bob,Paris,Analyst
Eve,London,Engineer,eighty thousand
John,New York,Supervisor,95000

Schreiben Sie ein Skript, das:

1. Lädt nur gültige Datensätze
2. Druckt die Anzahl der gültigen Zeilen aus
3. Schreibt sie an validated_employees.txt

# Tag 7: Erstellen Sie einen Mini -Datenprofiler (Projekttag)

Tolle Arbeit, um es so weit zu schaffen. Heute erstellen Sie ein eigenständiges Python -Skript, das:

• Lädt eine CSV -Datei
• Erkennt Spaltennamen und -Typen
• Berechnet nützliche Statistiken
• Schreibt einen Zusammenfassungsbericht

// Schritt-für-Schritt-Umriss

1. Laden Sie die Datei:

def load_csv(filename):
    with open(filename) as f:
        traces = (line.strip() for line in f if line.strip())
    header = traces(0).cut up(",")
    rows = (line.cut up(",") for line in traces(1:))
    return header, rows

2. Säulenstypen erkennen:

def detect_type(worth):
    strive:
        float(worth)
        return "numeric"
    besides:
        return "textual content"

3. Profil jede Spalte:

def profile_columns(header, rows):
    abstract = {}
    for i, col in enumerate(header):
        values = (row(i).strip() for row in rows if len(row) == len(header))
        col_type = detect_type(values(0))
        distinctive = set(values)
        abstract(col) = {
            "kind": col_type,
            "unique_count": len(distinctive),
            "most_common": max(set(values), key=values.rely)
 }
 if col_type == "numeric":
 nums = (float(v) for v in values if v.exchange('.', '', 1).isdigit())
 abstract(col)("common") = sum(nums) / len(nums) if nums else 0
 return abstract

4. Erstellen Sie eine Zusammenfassung:

def write_summary(abstract, out_file):
    with open(out_file, "w") as f:
        for col, stats in abstract.objects():
            f.write(f"Column: {col}n")
            for okay, v in stats.objects():
                f.write(f"  {okay}: {v}n")
            f.write("n")

Sie können die Funktionen wie SO verwenden:

header, rows = load_csv("workers.csv")
abstract = profile_columns(header, rows)
write_summary(abstract, "profile_report.txt")

// ⏭️ endgültige Übung

Verwenden Sie Ihre eigene CSV -Datei (oder verwenden Sie frühere). Führen Sie den Profiler aus und überprüfen Sie die Ausgabe.

# Abschluss

Glückwunsch! Sie haben den Python für den Mini-Course für Information Science abgeschlossen. 🎉

In dieser Woche haben Sie sich von grundlegenden Python -Datenstrukturen zum Schreiben modularer Funktionen und Skripte übergezogen, die reale Datenprobleme behandeln. Dies sind die Grundlagen, und damit meine ich wirklich grundlegende Sachen. Ich schlage vor, Sie verwenden dies als Ausgangspunkt und erfahren Sie mehr über die Standardbibliothek von Python (natürlich).

Danke, dass du mit mir gelernt hast. Pleased Coding und Daten knirschen voraus!

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.