Personalvermittler bitten Sie nicht mehr, die sechs normalen Formen zu rezitieren. Sie wollen dich hören Grund Über Daten um 2 Uhr morgens, wenn der primäre Shard heiß ist und der CFO auf die Stakeholder reagiert. Die Fragen, die Sie in diesem Artikel begegnen, wurden aus echten Interviews bei Google, Amazon, Stripe, Snowflake und einer Handvoll YC -Einhörnern geerntet. Jede Antwort ist lang genug, um das SQL -Muskelgedächtnis zu erfüllen, kurz genug, um in das Konversationsfenster zu passen, bevor der Interviewer nickt oder unterbricht. Verwenden Sie diese DBMS-Interviewfragen als Checkliste und dabei nicht exexhustiv.

Metrik für die Trennung

Ich habe die Fragen in drei Kategorien eingeteilt. Jede Kategorie ist auf ein bestimmtes Erfahrungsniveau zugeschnitten und steigt allmählich an. Die Liste enthält eine Mischung aus theoretischen Fragen, die während eines Interviews gestellt werden, und einige praktische Ergänzungen, um sich um die Pragmatik zu kümmern.

Anfänger

Diese Fragen sind für diejenigen related, die noch die Seile lernen.

Q1. Was ist ein Primärschlüssel und warum können wir nicht einfach verwenden? ROWID?

A. Ein Primärschlüssel ist a logisch, Einzigartige Kennung vom Designer ausgewählt. ROWID (oder ctid, _id usw.) ist a physisch Der vom Motor gehaltene Locator und kann sich nach Wartungsvorgängen wie Vakuum, Cluster-Nachbestellung oder Shard-Wiederausgleich ändern. Das Enthüllen eines physischen Zeigers würde in dem Second, in dem die Speicherschicht Seiten neu organisiert, auf dem neuesten Stand der Fremdschlüssel brechen. Ein Primärschlüssel ist dagegen unveränderlich und tragbar über Speichermotoren hinweg, was genau das ist, was die Referenzintegrität benötigt.

Q2. Erklären Sie logische Datenunabhängigkeit im Vergleich zur physikalischen Datenunabhängigkeit.

A. Logische Datenunabhängigkeit bedeutet, dass Sie die ändern können Logisches Schema (z. B. Hinzufügen von Attributen oder neuen Tabellen) ohne Umschreiben von Anwendungsprogrammen. Physikalische Datenunabhängigkeit bedeutet, dass Sie die ändern können Lagerstruktur (z. B. Indizes, Dateiorganisation), ohne das logische Schema oder die Abfragen zu beeinflussen.

Q3. Definieren Sie 1NF, 2NF und 3NF in einem Absatz und sagen Sie mir dann, welches Sie zuerst für Analytics entspannen würden.

A. 1nf: Jede Spalte enthält atomare, unteilbaren Werte (keine Arrays oder verschachtelten Tabellen). 2nf: 1nf Plus Jede Nicht-Style-Spalte ist vollständig von der abhängig gesamte Primärschlüssel (keine partielle Abhängigkeit). 3nf: 2nf Plus Keine transitive Abhängigkeit-Non-Key-Spalten hängen möglicherweise nicht von anderen Nicht-Schlüssel-Spalten ab. In Stern-Schema-Analysen lassen wir normalerweise zuerst 3NF fallen: Wir duplizieren den Segmentnamen des Kunden in der Faktentabelle gerne, um einen Be a part of zu sparen und Aktualisierungsanomalien für die Lesegeschwindigkeit zu akzeptieren.

This autumn. Was ist der Unterschied zwischen einem Schema und einer Instanz in einem DBM?

A. Die Schema ist das Gesamtdesign der Datenbank (ihre Blaupause), die normalerweise festgelegt und selten verändert wird. Der Beispiel ist der tatsächliche Inhalt der Datenbank zu einem bestimmten Zeitpunkt. Das Schema ist stabil; Die Instanz ändert sich jedes Mal, wenn Daten aktualisiert werden.

Q5. Geben Sie die vier Säureeigenschaften an und geben Sie eine Ein-Sekunden-Kriegsgeschichte, die gegen jeden verletzt.

A. Atomizität: Ein Debitposten, aber der Kredit verschwindet und das Geld verschwindet. Konsistenz: Ein negatives Gleichgewicht ist geschrieben; Die Überprüfungsbeschränkung feuert und die gesamte Transaktion rollt zurück. Isolierung: Zwei gleichzeitige Buchungen nehmen den letzten Sitz; Beide begehen und führen zu einem überverkauften Flug. Haltbarkeit: Commit Returns Success, Energy Fail, Write-Forward-Protokoll befindet sich auf der beschädigten SSD, was zu Datenverlust führt.

Q6. Was sind die verschiedenen Arten von Datenmodellen in DBMs?

A. Häufige Modelle umfassen:

• Objektorientiertes Modell (Objekte, Klassen, Vererbung).
• Hierarchisches Modell (Baumstruktur, Eltern-Form).
• Netzwerkmodell (durch Hyperlinks verbundene Datensätze).
• Relationales Modell (Tabellen, Schlüssel, Beziehungen).
• Entitätsbeziehungsmodell (Konzeptionaler Ebenen).

Sie haben einige Erfahrungen mit Datenbanken.

Q7. Was ist ein Impasse in DBMs? Wie kann es behandelt werden?

A. Impasse tritt auf, wenn zwei Transaktionen jeweils eine Ressource enthalten und auf die Ressource des anderen warten und für immer blockieren. Lösungen:

• Vermeidung (Banker -Algorithmus).
• Prävention (Sperrbestellung, Zeitüberschreitungen).
• Erkennung (Wait-for-Diagramm, Zykluserkennung).

Q8. Was ist Checkpointing in der DBMS -Wiederherstellung?

A. Ein Kontrollpunkt ist ein Marker, bei dem die DBMs Spült schmutzige Seiten und Protokolle zum stabilen Speicher. Während der Absturzwiederherstellung kann das System vom letzten Kontrollpunkt aus starten, anstatt das gesamte Protokoll zu scannen, was die Wiederherstellung schneller macht.

Q9. Was macht der Optimierer während eines wirklich? Kostenbasiert Schließen Sie sich der Wahl zwischen verschachteltem Schleifen, Hash und Zusammenführen an?

A. Es schätzt die Kardinalität jedes Kindes, konsultiert Spaltenstatistiken (häufigste Werte, Histogramme), berücksichtigt den verfügbaren Speicher (Work_MEM), Indizes und Sorten. Wenn die äußere Seite winzig ist (nach Filtern) und die innere Seite einen selektiven Index hat, gewinnt der verschachtelte Schleifen. Beide Seiten sind groß und ungeortiert, wodurch eine In-Reminiscence-Hash-Tabelle (Hash-Be a part of) erstellt wird. Wenn beide bereits sortiert sind (Index-Scan oder vorheriger Sortierschritt), ist Merge-Be a part of O (N+M) und Speichercheap. Die endgültige Kostenzahl ist I/O + CPU, gewichtet durch empirische Konstanten, die in pg_statisticist oder mysql.column_stats.

Q10. Erklären Phantom lesen und welches Isolationsniveau es verhindert.

A. Transaktion A läuft SELECT SUM(quantity) WHERE standing="PENDING" zweimal; Zwischen den Läufen fügt die Transaktion B eine neue ausstehende Zeile ein. A sieht eine andere Gesamtsumme – Phantom. Nur serialisierbare (oder Snapshot -Isolierung mit Prädikatsperrs) verhindert Phantome; Wiederholbares Lesen tut nicht (entgegen Folklore in Mysql).

Fortschrittlich

Sie haben Produktionsdaten gelöscht und dies durchlebt.

Q11. Ihr 2 TB -Tisch muss geschützt werden. Gib das genau Shard-Key-Entscheidungsbaum Sie würden sich gegen die CTO verteidigen.

A. 1: Hear Sie die Prime 10 Abfragen nach Frequenz und Bandbreite auf – Shard muss beides erfüllen.
2: Wählen Sie eine Hochkardinalität, gleichmäßig verteilte Säule (user_idnicht country_code).
3: Stellen Sie sicher, dass die Spalte in jeder Multi-Reihen-Transaktion angezeigt wird. Ansonsten wird zweiphasige Commit unvermeidlich.
4: Überprüfen Sie, ob Sie das Scorching-Spot-Risiko (z. B. ein Promi-Benutzer)-Hash-Shard + professional Shard AutoIncrement, nicht die Reichweite verwenden.
5: Beweisen Sie, dass Sie on-line mit logischer Replikation neu schützen können. Präsentieren Sie ein Dry-Run-Lower-Over-Skript. Erst wenn alle fünf Kästchen angekreuzt werden, unterschreiben Sie das Design -Dokument.

Q12. Führe mich durch die internen Schritte, die PostgreSQL von nimmt INSERT Aussage zu einem dauerhaften Scheiben -Byte.

A. 1: Parser → Uncooked Parse Tree.
2: Analysator → Baum mit Typen abfragen.
3: Planer → One-Node ModifyTable Plan.
4: Ausführender greift auf der Zielseite einen Pufferstift, fügt das Tupel ein und legt Xmin/Xmax -Systemspalten fest.
5: Wal -Rekord in gemeinsame Puffer eingefügt in Erinnerung.
6: Commit schreibt Wal über XLogwrite-jetzt Crash-Secure.
7: Hintergrundautor spülen später schmutzige Datenseiten; Wenn der Server vorher stirbt, wiederholen Sie die Wiederherstellung von Wal. Die Haltbarkeit ist in Schritt 6 garantiert, nicht Schritt 7.

Q13. Entwerfen Sie einen bitemporalen Tisch, der sich hält gültige Zeit (wenn die Tatsache in der Realität wahr struggle) und Transaktionszeit (als die Datenbank es wusste). Schreiben Sie den Primärschlüssel und den SQL, um eine rückwirkende Preisänderung zu korrigieren.

A. Primärschlüssel: (product_id, valid_from, transaction_from). Korrektur ist ein nur anhängen Einfügen mit einer neuen Transaktion einfügen. Keine Updates.

INSERT INTO worth(product_id, worth, valid_from, valid_to, transaction_from, transaction_to)

VALUES (42, 19.99, '2025-07-01', '2025-12-31', now(), '9999-12-31');

Um die vorherige falsche Behauptung zu beenden:

UPDATE worth SET transaction_to = now()

WHERE product_id = 42 AND valid_from <= '2025-07-01' AND valid_to > '2025-07-01'

  AND transaction_to = '9999-12-31';

Wählt jetzt verwendet FOR SYSTEM_TIME AS OF Und BETWEEN valid_from AND valid_to Um die richtige zeitliche Scheibe abzurufen.

Abschluss

Die Liste besteht aus einer vielseitigen Mischung aus Fragen von praktisch bis rein theoretisch. Dies bedeutet wirklich, dass Sie auf DBMS-Denken, nicht auf Syntax getestet werden: Schlüssel und Normalisierung, Säure- und Isolationsanomalien, Abfrageplanung, Wiederherstellung und Wal, Deadlocks, Shard-Kee-Strategie, Postgres-Interna und bitemporale Modellierung. Ziel ist es, Kompromisse, Invarianten, Fehlermodi und operatives Urteilsvermögen zu ermitteln.

Auswendiglernen Klauseln überspringen. Zeigen Sie, warum Primärschlüsse Rowids überleben, wenn wiederholbare Lesen immer noch Phantome durchlaufen, warum ein Hash -Beitritt zu verschachtelten Loops und wie Sie ohne Ausfallzeiten neu gestellt würden. Wenn Sie diese Entscheidungen laut durchgehen können, werden Sie als Ingenieur für Datensysteme auftreten.

Wenn Sie in einem Interview mit einem Datenbankingenieur wirklich alles durchmachen möchten, durch die folgenden Ressourcen:

Ich bin spezialisiert auf die Überprüfung und Verfeinerung von KI-gesteuerten Forschungen, technischen Dokumentationen und Inhalten im Zusammenhang mit aufstrebenden KI-Technologien. Meine Erfahrung umfasst das KI -Modelltraining, die Datenanalyse und das Abrufen von Informationen, sodass ich Inhalte herstellen kann, die sowohl technisch genau als auch zugänglich sind.

class AdvancedNeuralAgent:
   def __init__(self, input_size, hidden_layers=(64, 32), output_size=1, learning_rate=0.001):
       """Superior AI Agent with steady coaching and choice making capabilities"""
       self.lr = learning_rate
       self.initial_lr = learning_rate
       self.layers = ()
       self.reminiscence = ()
       self.performance_history = ()
       self.epsilon = 1e-8 
      
       layer_sizes = (input_size) + hidden_layers + (output_size)
       for i in vary(len(layer_sizes) - 1):
           fan_in, fan_out = layer_sizes(i), layer_sizes(i+1)
           restrict = np.sqrt(6.0 / (fan_in + fan_out))
          
           layer = {
               'weights': np.random.uniform(-limit, restrict, (layer_sizes(i), layer_sizes(i+1))),
               'bias': np.zeros((1, layer_sizes(i+1))),
               'momentum_w': np.zeros((layer_sizes(i), layer_sizes(i+1))),
               'momentum_b': np.zeros((1, layer_sizes(i+1)))
           }
           self.layers.append(layer)
  
   def activation(self, x, func="relu"):
       """Steady activation features with clipping"""
       x = np.clip(x, -50, 50) 
      
       if func == 'relu':
           return np.most(0, x)
       elif func == 'sigmoid':
           return 1 / (1 + np.exp(-x))
       elif func == 'tanh':
           return np.tanh(x)
       elif func == 'leaky_relu':
           return np.the place(x > 0, x, x * 0.01)
       elif func == 'linear':
           return x
  
   def activation_derivative(self, x, func="relu"):
       """Steady derivatives"""
       x = np.clip(x, -50, 50)
      
       if func == 'relu':
           return (x > 0).astype(float)
       elif func == 'sigmoid':
           s = self.activation(x, 'sigmoid')
           return s * (1 - s)
       elif func == 'tanh':
           return 1 - np.tanh(x)**2
       elif func == 'leaky_relu':
           return np.the place(x > 0, 1, 0.01)
       elif func == 'linear':
           return np.ones_like(x)
  
   def ahead(self, X):
       """Ahead move with gradient clipping"""
       self.activations = (X)
       self.z_values = ()
      
       current_input = X
       for i, layer in enumerate(self.layers):
           z = np.dot(current_input, layer('weights')) + layer('bias')
           z = np.clip(z, -50, 50) 
           self.z_values.append(z)
          
           if i < len(self.layers) - 1: 
               a = self.activation(z, 'leaky_relu')
           else: 
               a = self.activation(z, 'linear')
          
           self.activations.append(a)
           current_input = a
      
       return current_input
  
   def clip_gradients(self, gradients, max_norm=1.0):
       """Gradient clipping to forestall explosion"""
       grad_norm = np.linalg.norm(gradients)
       if grad_norm > max_norm:
           gradients = gradients * (max_norm / (grad_norm + self.epsilon))
       return gradients
  
   def backward(self, X, y, output):
       """Steady backpropagation with gradient clipping"""
       m = X.form(0)
      
       dz = (output - y.reshape(-1, 1)) / m
       dz = np.clip(dz, -10, 10)
      
       for i in reversed(vary(len(self.layers))):
           layer = self.layers(i)
          
           dw = np.dot(self.activations(i).T, dz)
           db = np.sum(dz, axis=0, keepdims=True)
          
           dw = self.clip_gradients(dw, max_norm=1.0)
           db = self.clip_gradients(db, max_norm=1.0)
          
           momentum = 0.9
           layer('momentum_w') = momentum * layer('momentum_w') + (1 - momentum) * dw
           layer('momentum_b') = momentum * layer('momentum_b') + (1 - momentum) * db
          
           weight_decay = 0.0001
           layer('weights') -= self.lr * (layer('momentum_w') + weight_decay * layer('weights'))
           layer('bias') -= self.lr * layer('momentum_b')
          
           if i > 0:
               activation_func="leaky_relu" if i > 1 else 'leaky_relu'
               dz = np.dot(dz, layer('weights').T) * self.activation_derivative(
                   self.z_values(i-1), activation_func)
               dz = np.clip(dz, -10, 10) 
  
   def adapt_learning_rate(self, epoch, performance_history):
       """Adaptive studying fee with performance-based adjustment"""
       if epoch > 10:
           recent_performance = performance_history(-10:)
           if len(recent_performance) >= 5:
               if recent_performance(-1) >= recent_performance(-5):
                   self.lr = max(self.lr * 0.95, self.initial_lr * 0.01)
               elif recent_performance(-1) < recent_performance(-5) * 0.98:
                   self.lr = min(self.lr * 1.02, self.initial_lr * 2)
  
   def calculate_loss(self, y_true, y_pred):
       """Steady loss calculation"""
       y_true = y_true.reshape(-1, 1)
       y_pred = np.clip(y_pred, -1e6, 1e6) 
      
       mse = np.imply((y_true - y_pred) ** 2)
       mae = np.imply(np.abs(y_true - y_pred))
      
       if not np.isfinite(mse):
           mse = 1e6
       if not np.isfinite(mae):
           mae = 1e6
          
       return mse, mae
  
   def store_experience(self, state, motion, reward, next_state):
       """Expertise replay for RL points"""
       expertise = {
           'state': state,
           'motion': motion,
           'reward': reward,
           'next_state': next_state,
           'timestamp': len(self.reminiscence)
       }
       self.reminiscence.append(expertise)
      
       if len(self.reminiscence) > 1000:
           self.reminiscence.pop(0)
  
   def make_decision(self, X, exploration_rate=0.1):
       """Steady choice making"""
       prediction = self.ahead(X)
      
       if np.random.random() < exploration_rate:
           noise_scale = np.std(prediction) * 0.1 if np.std(prediction) > 0 else 0.1
           noise = np.random.regular(0, noise_scale, prediction.form)
           prediction += noise
      
       return np.clip(prediction, -1e6, 1e6)
  
   def reset_if_unstable(self):
       """Reset community if coaching turns into unstable"""
       print(" Resetting community as a result of instability...")
       for i, layer in enumerate(self.layers):
           fan_in, fan_out = layer('weights').form
           restrict = np.sqrt(6.0 / (fan_in + fan_out))
           layer('weights') = np.random.uniform(-limit, restrict, (fan_in, fan_out))
           layer('bias') = np.zeros((1, fan_out))
           layer('momentum_w') = np.zeros((fan_in, fan_out))
           layer('momentum_b') = np.zeros((1, fan_out))
       self.lr = self.initial_lr
  
   def practice(self, X, y, epochs=500, batch_size=32, validation_split=0.2, verbose=True):
       """Strong coaching with stability checks"""
       y_mean, y_std = np.imply(y), np.std(y)
       y_normalized = (y - y_mean) / (y_std + self.epsilon)
      
       X_trn, X_val, y_trn, y_val = train_test_split(
           X, y_normalized, test_size=validation_split, random_state=42)
      
       best_val_loss = float('inf')
       endurance = 30
       patience_counter = 0
      
       train_losses, val_losses = (), ()
       reset_count = 0
      
       for epoch in vary(epochs):
           if epoch > 0 and (not np.isfinite(train_losses(-1)) or train_losses(-1) > 1e6):
               if reset_count < 2: 
                   self.reset_if_unstable()
                   reset_count += 1
                   proceed
               else:
                   print(" Coaching unstable, stopping...")
                   break
          
           indices = np.random.permutation(len(X_train))
           X_train_shuffled = X_train(indices)
           y_train_shuffled = y_train(indices)
          
           epoch_loss = 0
           batches = 0
           for i in vary(0, len(X_trn), batch_size):
               batch_X = X_train_shuffled(i:i+batch_size)
               batch_y = y_train_shuffled(i:i+batch_size)
              
               if len(batch_X) == 0:
                   proceed
              
               output = self.ahead(batch_X)
               self.backward(batch_X, batch_y, output)
              
               loss, _ = self.calculate_loss(batch_y, output)
               epoch_loss += loss
               batches += 1
          
           avg_train_loss = epoch_loss / max(batches, 1)
          
           val_output = self.ahead(X_val)
           val_loss, val_mae = self.calculate_loss(y_val, val_output)
          
           train_losses.append(avg_train_loss)
           val_losses.append(val_loss)
           self.performance_history.append(val_loss)
          
           if val_loss < best_val_loss:
               best_val_loss = val_loss
               patience_counter = 0
           else:
               patience_counter += 1
          
           if patience_counter >= endurance:
               if verbose:
                   print(f" Early stopping at epoch {epoch}")
               break
          
           if epoch > 0:
               self.adapt_learning_rate(epoch, self.performance_history)
          
           if verbose and (epoch % 50 == 0 or epoch < 10):
               print(f"Epoch {epoch:3d}: Practice Loss = {avg_train_loss:.4f}, "
                     f"Val Loss = {val_loss:.4f}, LR = {self.lr:.6f}")
      
       self.y_mean, self.y_std = y_mean, y_std
       return train_losses, val_losses
  
   def predict(self, X):
       """Make predictions with denormalization"""
       normalized_pred = self.ahead(X)
       if hasattr(self, 'y_mean') and hasattr(self, 'y_std'):
           return normalized_pred * self.y_std + self.y_mean
       return normalized_pred
  
   def evaluate_performance(self, X, y):
       """Complete efficiency analysis"""
       predictions = self.predict(X)
       mse, mae = self.calculate_loss(y, predictions)
      
       y_mean = np.imply(y)
       ss_tot = np.sum((y - y_mean) ** 2)
       ss_res = np.sum((y.reshape(-1, 1) - predictions) ** 2)
       r2 = 1 - (ss_res / (ss_tot + self.epsilon))
      
       return {
           'mse': float(mse) if np.isfinite(mse) else float('inf'),
           'mae': float(mae) if np.isfinite(mae) else float('inf'),
           'r2': float(r2) if np.isfinite(r2) else -float('inf'),
           'predictions': predictions.flatten()
       }
  
   def visualize_training(self, train_losses, val_losses):
       """Visualize coaching progress"""
       plt.determine(figsize=(15, 5))
      
       plt.subplot(1, 3, 1)
       plt.plot(train_losses, label="Coaching Loss", alpha=0.8)
       plt.plot(val_losses, label="Validation Loss", alpha=0.8)
       plt.title('Coaching Progress')
       plt.xlabel('Epoch')
       plt.ylabel('Loss')
       plt.legend()
       plt.grid(True, alpha=0.3)
       plt.yscale('log')
      
       plt.subplot(1, 3, 2)
       if len(self.performance_history) > 0:
           plt.plot(self.performance_history)
           plt.title('Efficiency Historical past')
           plt.xlabel('Epoch')
           plt.ylabel('Validation Loss')
           plt.grid(True, alpha=0.3)
           plt.yscale('log')
      
       plt.subplot(1, 3, 3)
       if hasattr(self, 'lr_history'):
           plt.plot(self.lr_history)
           plt.title('Studying Charge Schedule')
           plt.xlabel('Epoch')
           plt.ylabel('Studying Charge')
           plt.grid(True, alpha=0.3)
      
       plt.tight_layout()
       plt.present()

Bild von Editor | Chatgpt

Das Visualisierung von Daten kann sich anfühlen, um zu versuchen, ein Meisterwerk mit einem stumpfen Bleistift zu skizzieren. Sie wissen, was Sie erstellen möchten, aber das Werkzeug in Ihrer Hand ist einfach nicht kooperiert. Wenn Sie jemals ein Durcheinander von Code gestarrt haben und Ihr Matplotlib -Diagramm weniger wie eine unordentliche Ausgabe aussehen lassen, sind Sie nicht allein.

Ich erinnere mich an mein erstes Mal mit Matplotlib. Ich musste Temperaturdaten für ein Projekt zeichnen, und nach stundenlangem Googeln „Wie man X-Achse-Etiketten dreht“ hatte ich ein Diagramm, das so aussah, als ob es einen Twister überlebte. Klingt vertraut? Deshalb habe ich diesen Leitfaden zusammengestellt – um Ihnen zu helfen, die Frustration zu überspringen und saubere, professionelle Handlungen zu erstellen, die tatsächlich Sinn machen.

Warum Matplotlib? (Und warum es sich manchmal klobig anfühlt)

Matplotlib ist der Großvater von Python -Ploting -Bibliotheken. Es ist mächtig, flexibel und … sagen wir, schrullig. Anfänger stellen oft Fragen wie:

• „Warum erfordert etwas so Einfaches wie ein Balkendiagramm 10 Codezeilen?“
• „Wie kann ich meine Handlungen davon abhalten, aus 1995 auszusehen?“
• „Gibt es eine Möglichkeit, dies weniger schmerzhaft zu machen?“

Die kurze Antwort auf diese? Ja.

Matplotlib verfügt über eine Lernkurve, aber sobald Sie seine Logik erfasst, werden Sie endlose Anpassungen freischalten. Stellen Sie sich vor, Sie lernen, dass Sie zuerst eine Schaltschicht fahren lassen: Sie werden jedoch bald ohne nachzudenken.

Erste Schritte: Ihre erste Handlung in 5 Minuten

Bevor wir in fortgeschrittene Methods eintauchen, nageln wir die Grundlagen. Installieren Matplotlib mit pip set up matplotlibVersuchen Sie es dann.

Erstes, was zu tun ist: Importieren Sie Matplotlib auf herkömmliche Weise.

import matplotlib.pyplot as plt

Erstellen wir einige Beispieldaten:

years = (2010, 2015, 2020)
gross sales = (100, 250, 400)

Lassen Sie uns nun eine Figur und eine Achse erstellen:

Zeit, um die Daten zu zeichnen:

ax.plot(years, gross sales, marker="o", linestyle="--", colour="inexperienced")

Fügen Sie nun Etiketten und einen Titel hinzu:

ax.set_xlabel('Yr')
ax.set_ylabel('Gross sales (in 1000's)')
ax.set_title('Firm Development: 2010-2020')

Schließlich müssen wir das Diagramm anzeigen:

Was passiert hier?

• plt.subplots() erstellt eine Figur (die Leinwand) und eine Achse (der Plotbereich)
• ax.plot() Zeichnet ein Zeilendiagramm. Die Marker-, Linestyle- und Farbargumente jazzieren es auf
• Etiketten und Titel werden mit hinzugefügt mit hinzugefügt set_xlabel()Anwesend set_ylabel()Und set_title()

Professional -Tipp: Beschriften Sie Ihre Achsen immer! Eine unbeschreibene Handlung bringt Verwirrung und erscheint unprofessionell.

Die Anatomie eines Matplotlib -Diagramms

Um Matplotlib zu beherrschen, müssen Sie seine Sprache sprechen. Hier ist eine Aufschlüsselung der Schlüsselkomponenten:

• Abbildung: Das gesamte Fenster oder die gesamte Seite. Es ist das große Bild.
• Achsen: Wo das Diagramm passiert. Eine Figur kann mehrere Achsen haben (denken Sie an Nebenhandlungen).
• Achse: Die X- und Y -Herrscher, die die Datengrenzen definieren.
• Künstler: Alles, was Sie sehen, von Textual content über Linien bis hin zu Markierungen.

Verwirrt über Figuren gegen Achsen? Stellen Sie sich die Figur als Bilderrahmen und die Achsen als Foto im Inneren vor.

Nächste Schritte

OK, es ist Zeit, deinen PLOST zu machen … weniger hässlich. Matplotlibs Standardstil schreit „Akademisches Papier von 2003“. Lassen Sie uns es modernisieren. Hier sind einige Strategien.

1. Verwenden Sie Stylesheets

Stylesheets sind vorkonfigurierte Paletten, um Ihre Arbeit zusammenhängende Färbung zu verleihen:

Weitere Optionen, die Sie für die Stylesheet -Farbkonfigurationen verwenden können seabornAnwesend fivethirtyeightAnwesend dark_background.

2. Anpassen Sie Farben und Schriftarten

Geben Sie sich nicht mit den Standardfarben oder Schriftarten zufrieden und fügen Sie eine gewisse Personalisierung hinzu. Es braucht nicht viel, um dies zu tun:

ax.plot(years, gross sales, colour="#2ecc71", linewidth=2.5)
ax.set_xlabel('Yr', fontsize=12, fontfamily='Arial')

3. Fügen Sie Gitter hinzu (aber sparsam)

Sie möchten nicht, dass Netze überwältigend werden, aber wenn Sie sie garantiert haben, können Sie Ihre Arbeit ein gewisses Aptitude und Nutzen bringen:

ax.grid(True, linestyle="--", alpha=0.6) 

4.. Anmerkende wichtige Punkte

Gibt es einen Datenpunkt, der eine zusätzliche Erklärung benötigt? Annotieren Sie gegebenenfalls:

ax.annotate('Document Gross sales in 2020!', xy=(2020, 400), xytext=(2018, 350),
    arrowprops=dict(facecolor="black", shrink=0.05))

Aufwertung: Fortgeschrittene Techniken

1. Nebenhandlungen: Multitasking für Handlungen

Wenn Sie mehrere Diagramme nebeneinander anzeigen müssen, erstellen Sie Sublots, um 2 Zeilen und 1 Spalte zu erstellen.

fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(8, 6)) axes(0).plot(years, gross sales, colour="blue")  
axes(1).scatter(years, gross sales, colour="pink")  
plt.tight_layout()

Die letzte Zeile verhindert überlappend.

2. Wärme- und Konturdiagramme

Visualisieren Sie 3D -Daten in 2D:

import numpy as np

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

contour = ax.contourf(X, Y, Z, cmap='viridis')

Wenn Sie eine Farbskala hinzufügen möchten:

3. Interaktive Diagramme

Zeit, um Ihre Diagramme anklicken zu lassen mplcursors:

import mplcursors

line, = ax.plot(years, gross sales)
mplcursors.cursor(line).join("add", lambda sel: sel.annotation.set_text(f"Gross sales: ${sel.goal(1)}ok"))

Einpacken

Bevor Sie hier rauskommen, werfen wir einen kurzen Blick auf die gängigen Matplotlib -Kopfschmerzen und deren Korrekturen:

• „Meine Etiketten sind abgeschnitten!“ – Verwenden plt.tight_layout() oder die Polsterung mit Abb.
• „Warum ist meine Handlung leer?!“ – vergessen plt.present() Jupyter verwenden? Hinzufügen %matplotlib an der Spitze inline
• „Die Schriftarten sehen pixelig aus“ – Vektorformate (PDF, SVG) mit speichern plt.savefig('plot.pdf', dpi=300)

Wenn Sie bereit sind, selbst zu experimentieren, sollten Sie jetzt einige Herausforderungen machen, die Sie jetzt abschließen können. Wenn Sie stecken bleiben, teilen Sie Ihren Code in den Kommentaren und lassen Sie uns gemeinsam beheben.

• Passen Sie ein Histogramm an die Markenfarben Ihres Unternehmens an
• Erstellen Sie ein Diagramm aus einem kürzlich veröffentlichten Nachrichtenartikel so intestine Sie können
• Animieren Sie ein Diagramm, das Datenänderungen im Laufe der Zeit zeigt (Hinweis: Versuchen Sie FuncAnimation)

Zuletzt entwickelt sich Matplotlib, ebenso wie Ihr Wissen. Setzen Sie ein Lesezeichen für diese Ressourcen, um sie beim Fortschritt zu überprüfen:

Abschluss

Matplotlib ist nicht nur eine Bibliothek – es ist ein Toolkit für das Geschichtenerzählen. Unabhängig davon, ob Sie Klimadaten visualisieren oder Verkaufstrends darstellen, ist das Ziel Klarheit. Denken Sie daran, selbst Experten Google „Wie man manchmal eine zweite Y-Achse hinzufügt“. Der Schlüssel ist, einfach zu beginnen, oft zu iterieren und die Dokumentation nicht fürchten.

Shittu Olumide ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich für die Nutzung hochmoderner Technologien für überzeugende Erzählungen befindet, mit einem scharfen Auge für Particulars und einem Händchen zur Vereinfachung komplexer Konzepte. Sie können auch Shittu finden Twitter.