Python-Spickzettel: Wichtige schnelle und einfache Anleitung

Wenn Sie in Python programmieren , kann es bahnbrechend sein, einen zuverlässigen Spickzettel an Ihrer Seite zu haben. Python mag für seine Einfachheit und Lesbarkeit bekannt sein, aber es lässt sich nicht leugnen, dass die umfangreiche Palette an Features und Funktionalitäten zu viel ist, um sie sich einzuprägen!

Python-Spickzettel dienen sowohl Anfängern als auch erfahrenen Entwicklern als praktische Referenz. Sie bieten ein grundlegendes Referenzhandbuch für verschiedene Befehle, Syntax, Datenstrukturen und mehr.

Bei diesem Leitfaden handelt es sich um einen Python-Spickzettel, der Ihnen beim Navigieren durch verschiedene Funktionen , Bibliotheken, Klassen und Syntaxen helfen kann, die insbesondere für Anfänger überwältigend sein können.

Bist du altmodisch? Bevor Sie es herunterladen und ausdrucken, sehen Sie sich bitte das folgende PDF an, um Sie auf Ihrer Python-Lernreise zu unterstützen!

Python-Cheat-Sheet-1 herunterladen

Inhaltsverzeichnis

• Kurzreferenz für die Grundlagen der Python-Syntax
  • 1. Kommentare
  • 2. Variablen
  • 3. Datentypen
  • 4. Bedingte Anweisungen
  • 5. Schleifen
  • 6. Funktionen
• Kurzreferenz für Python-Datenstrukturen
  • 1. Listen
  • 2. Tupel
  • 3. Sets
  • 4. Wörterbücher
• Kurzreferenz für Python-Datei-I/O
  • 1. Dateien lesen
  • 2. Dateien schreiben
  • 3. An Dateien anhängen
• Kurzreferenz zur Fehlerbehandlung in Python
  • 1. Versuchen Sie es mit Ausnahme
  • 2. Endlich
  • 3. Ausnahmen auslösen
• Kurzreferenz für Python-Module und -Pakete
  • 1. Module importieren
  • 2. Pakete erstellen
• Kurzreferenz für objektorientierte Programmierung in Python
  • 1. Klassen
  • 2. Vererbung
  • 3. Kapselung
• 4 hilfreiche Python-Bibliotheken
  • 1. NumPy
  • 2. Pandas
  • 3. Anfragen
  • 4. Schöne Suppe
• Abschließende Gedanken

Kurzreferenz für die Grundlagen der Python-Syntax

Zum Auftakt unseres Python-Spickzettels beschäftigen wir uns mit einigen Grundlagen der Python-Syntax. Wenn Sie über fundierte Kenntnisse der Python-Grundlagen verfügen, erhalten Sie eine solide Grundlage für das Schreiben komplexerer Codes.

Für diese Referenz haben wir Folgendes eingefügt: Kommentare , Variablen , Datentypen , bedingte Anweisungen , Schleifen und Funktionen .

1. Kommentare

Kommentare sind ein wichtiger Teil Ihres Codes, da sie es Ihnen ermöglichen, Ihren Denkprozess zu erläutern und Ihren Code lesbarer zu machen. In Python können Sie einzeilige Kommentare mit dem Hash-Symbol (#) erstellen.

# This is a single-line comment.

Für mehrzeilige Kommentare können Sie dreifache Anführungszeichen (einfache oder doppelte) verwenden.

""" This is a
multi-line
comment. """

2. Variablen

Variablen in Python werden zum Speichern von Daten verwendet. Mithilfe des Gleichheitszeichens (=) können Sie Variablen Werte zuweisen.

x = 5
name = "John"

Variablennamen sollten beschreibend sein und der Namenskonvention folgen, die Kleinbuchstaben und Unterstriche für Leerzeichen verwendet.

user_age = 25
favorite_color = "blue"

3. Datentypen

In der Python-Sprache sind standardmäßig mehrere Datentypen integriert. Zu den häufigeren gehören:

• Texttypen : str

• Boolescher Typ : bool

• Numerische Typen : int, float, complex

• Sequenztypen : Liste, Tupel, Bereich

• Keiner Typ: Keiner Typ

Um den Datentyp eines beliebigen Python-Objekts herauszufinden, können Sie die Funktion type() verwenden . Zum Beispiel:

name = 'jane'
print(type(name))

#Output: 'str'

4. Bedingte Anweisungen

Mit bedingten Anweisungen in Python können Sie Code nur dann ausführen, wenn bestimmte Bedingungen erfüllt sind. Die häufigsten bedingten Anweisungen sind „ if “, „elif “ und „ else “.

if condition:
    # Code to execute if the condition is true
elif another_condition:
    # Code to execute if the another_condition is true
else:
    # Code to execute if none of the conditions are true

5. Schleifen

Eine Schleife wird verwendet, um einen Codeblock wiederholt auszuführen. Python verfügt über zwei Arten von Schleifen: eine „ for “-Schleife und eine „ while “-Schleife.

Werfen wir einen Blick auf beide:

Für Schleifen:

for variable in iterable:
    # Code to execute for each element in the iterable

While-Schleifen:

while condition:
    # Code to execute while the condition is true

Innerhalb dieser Schleifen können Sie Bedingungs- und Steueranweisungen verwenden, um den Ablauf Ihres Programms zu steuern.

6. Funktionen

Funktionen in Python sind Codeblöcke, die bestimmte Aufgaben ausführen. Sie können eine Funktion mit dem Schlüsselwort „ def “ definieren, gefolgt vom Funktionsnamen und Klammern, die etwaige Eingabeparameter enthalten.

def function_name(parameters):
    # Code to execute
    return result

Um eine Funktion aufzurufen, verwenden Sie den Funktionsnamen gefolgt von Klammern mit den erforderlichen Argumenten.

function_name(arguments)

Nachdem wir uns nun mit den Python-Grundlagen befasst haben, gehen wir im nächsten Abschnitt zu einigen fortgeschritteneren Themen über.

Kurzreferenz für Python-Datenstrukturen

Als Nächstes besprechen wir in unserem Python-Cheatsheet einige der am häufigsten verwendeten Datenstrukturen in Python. Diese Datenstrukturen sind für die Verwaltung und Organisation der Daten in Ihren Programmierprojekten von entscheidender Bedeutung.

Es gibt viele Datenstrukturen in Python, die fortgeschrittene Entwickler verwenden können. Wir konzentrieren uns jedoch auf Listen , Tupel , Mengen und Wörterbücher .

1. Listen

Eine Liste in Python ist eine veränderbare, geordnete Folge von Elementen. Um eine Liste zu erstellen, verwenden Sie eckige Klammern und trennen Sie die Elemente durch Kommas.

Python-Listen können eine Vielzahl von Datentypen wie Zeichenfolgen, Ganzzahlen, Boolesche Werte usw. enthalten. Hier sind einige Beispiele für Operationen, die Sie mit Python- Listen ausführen können:

• Erstelle eine Liste:

  my_list = [1, 2, 3]

• Zugriffselemente:

  my_list[0]

• Fügen Sie ein Element hinzu:

  my_list.append(4)

2. Tupel

Ein Tupel ähnelt einer Liste, ist jedoch unveränderlich, was bedeutet, dass Sie seine Elemente nach der Erstellung nicht ändern können. Sie können ein Tupel erstellen, indem Sie Klammern verwenden und die Elemente durch Kommas trennen.

Hier sind einige Beispiele für Tupeloperationen:

• Erstellen Sie ein Tupel:

  my_tuple = (1, 2, 3)

• Zugriffselemente:

  my_tuple[0] #Output: 1

3. Sets

Eine Menge ist eine ungeordnete Sammlung einzigartiger Elemente. Sie können einen Satz mit der Funktion set() oder mit geschweiften Klammern erstellen.

Es kann auch verschiedene Datentypen enthalten, sofern diese eindeutig sind. Hier sind einige Beispiele für Mengenoperationen:

• Erstellen Sie ein Set:

   my_set = {1, 2, 3}

• Fügen Sie ein Element hinzu:

  my_set.add(4)

• Ein Element entfernen:

  my_set.remove(1)

4. Wörterbücher

Ein Wörterbuch ist eine ungeordnete Sammlung von Schlüssel-Wert-Paaren, deren Schlüssel eindeutig sind. Sie können ein Wörterbuch erstellen, indem Sie geschweifte Klammern verwenden und die Schlüssel und Werte durch Doppelpunkte trennen. Hier sind einige Beispiele für Wörterbuchoperationen:

• Erstellen Sie ein Wörterbuch:

  my_dict = {'key1': 'value1', 'key2': 'value2'}

• Zugriffselemente:

  my_dict['key1'] #Output:'value1'

• Fügen Sie ein Schlüssel-Wert-Paar hinzu:

  my_dict['key3'] = 'value3'

• Entfernen Sie ein Schlüssel-Wert-Paar:

  del my_dict['key1']

Denken Sie daran, diese Datenstrukturen in Ihren Python-Projekten zu üben und zu erkunden, um ihre Verwendung besser zu beherrschen! Als Nächstes geben wir Ihnen eine Referenz für Datei-E/A-Aufgaben.

Quick Reference for Python File I/O

In this section of the Python cheat sheet, we’ll focus on some common tasks related to working with files in Python, such as reading, writing, and appending data.

1. Reading Files

To read a file, you first need to open it using the built-in open() function, with the mode parameter set to ‘r‘ for reading:

file_obj = open('file_path', 'r')

Now that your file is open, you can use different methods to read its content:

• read(): Reads the entire content of the file.

• readline(): Reads a single line from the file.

• readlines(): Returns a list of all lines in the file.

It’s important to remember to close the file once you’ve finished working with it:

file_obj.close()

Alternatively, you can use the with statement, which automatically closes the file after the block of code completes:

with open('file_path', 'r') as file_obj:
    content = file_obj.read()

2. Writing Files

To create a new file or overwrite an existing one, open the file with mode ‘w‘:

file_obj = open('file_path', 'w')

Write data to the file using the write() method:

file_obj.write('This is a line of text.')

Don’t forget to close the file:

file_obj.close()

Again, consider using the with statement for a more concise and safer way to handle files:

with open('file_path', 'w') as file_obj:
    file_obj.write('This is a line of text.')

3. Appending to Files

To add content to an existing file without overwriting it, open the file with mode ‘a‘:

file_obj = open('file_path', 'a')

Use the write() method to append data to the file:

file_obj.write('This is an extra line of text.')

And, as always, close the file when you’re done:

file_obj.close()

For a more efficient and cleaner approach, use the with statement:

with open('file_path', 'a') as file_obj:
    file_obj.write('This is an extra line of text.')

By following these steps and examples, you can efficiently navigate file operations in your Python applications. Remember to always close your files after working with them to avoid potential issues and resource leaks!

In the next section, we provide a reference for error handling in Python.

Quick Reference for Error Handling in Python

In this section, you’ll learn about error handling in Python, which plays a crucial role in preventing the abrupt termination of your programs when it encounters an error.

We’ll cover the following sub-sections: Try and Except, Finally, and Raising Exceptions.

1. Try and Except

To handle exceptions in your code, you can use the try and except blocks. The try block contains the code that might raise an error, whereas the except block helps you handle that exception, ensuring your program continues running smoothly.

Here’s an example:

try:
    quotient = 5 / 0

except ZeroDivisionError as e:
    print("Oops! You're trying to divide by zero.")

In this case, the code inside the try block will raise a ZeroDivisionError exception. Since we have an except block to handle this specific exception, it will catch the error and print the message to alert you about the issue.

2. Finally

The finally block is used when you want to ensure that a specific block of code is executed, no matter the outcome of the try and except blocks. This is especially useful for releasing resources or closing files or connections, even if an exception occurs, ensuring a clean exit.

Here’s an example:

try:
    # Your code here
except MyException as e:
    # Exception handling
finally:
    print("This will run no matter the outcome of the try and except blocks.")

3. Raising Exceptions

You can also raise custom exceptions in your code to trigger error handling when specific conditions are met. To do this, you can use the raise statement followed by the exception you want to raise (either built-in or custom exception).

For instance:

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be a negative value.")

try:
    validate_age(-3)
except ValueError as ve:
    print(ve)

In this example, we’ve defined a custom function to validate an age value. If the provided age is less than zero, we raise a ValueError with a custom message. When calling this function, you should wrap it in a try-except block to handle the exception properly.

Next, we’re going to provide a quick reference for popular Python modules and packages. Let’s go!

Quick Reference for Python Modules and Packages

This section of our cheat sheet is for Python packages and modules, which are essential for structuring and organizing your code cleanly and efficiently.

You’ll learn about importing modules and creating packages.

1. Importing Modules

Modules in Python are files containing reusable code, such as functions, classes, or variables. Python offers several modules and packages for different tasks like data science, machine learning, robotics, etc.

To use a module’s contents in your code, you need to import it first. Here are a few different ways to import a module:

• import : This imports the entire module, and you can access its contents using the syntax ‘module_name.content_name.’
  For example:

  import random
  
  c = random.ranint()

• from import : This imports a specific content (function or variable) from the module, and you can use it directly without referencing the module name.

  from math import sin
  
  c = sin(1.57)

• from import *: This imports all contents of the module. Be careful with this method as it can lead to conflicts if different modules have contents with the same name.

Some commonly used built-in Python modules include:

1. math: Provides mathematical functions and constants

2. random: Generates random numbers and provides related functions

3. datetime: Handles date and time operations

4. os: Interacts with the operating system and manages files and directories

2. Creating Packages

Packages in Python are collections of related modules. They help you organize your code into logical and functional units. To create a package:

1. Create a new directory with the desired package name.

2. Add an empty file named init.py to the directory. This file indicates to Python that the directory should be treated as a package.

3. Add your module files (with the .py extension) to the directory.

Now, you can import the package or its modules into your Python scripts. To import a module from a package, use the syntax:

import 

Structure your code with modules and packages to make it more organized and maintainable. This will also make it easier for you and others to navigate and comprehend your codebase.

In the next section, we provide a reference for object-oriented programming concepts in Python.

Quick Reference for Object-Oriented Programming in Python

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects“, which can contain data and code.

The data is in the form of fields, often known as attributes or properties, and the code is in the form of procedures, often known as methods.

In this section of the cheat sheet, we’ll delve into the fundamental concepts of OOP in Python, including classes, inheritance, and encapsulation.

1. Classes

A class is a blueprint for creating objects. It defines the data (attributes) and functionality (methods) of the objects. To begin creating your own class, use the “class” keyword followed by the class name:

class ClassName:
    # Class attributes and methods

To add attributes and methods, simply define them within the class block. For example:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof!")

In diesem Beispiel kann ein neues Hundeobjekt mit einem Namen und einer Rasse erstellt werden, und es verfügt über eine Rindenmethode, die „ Woof!“ ausgibt. “, wenn angerufen.

2. Vererbung

Durch Vererbung kann eine Klasse Attribute und Methoden von einer anderen Klasse erben, was die Wiederverwendbarkeit und Modularität des Codes ermöglicht. Die Klasse, die erbt, wird als Unterklasse oder abgeleitete Klasse bezeichnet, während die Klasse, von der geerbt wird, als Basisklasse oder Oberklasse bezeichnet wird.

Um die Vererbung zu implementieren, fügen Sie den Namen der Oberklasse in Klammern nach dem Namen der Unterklasse hinzu:

class SubclassName(SuperclassName):
    # Subclass attributes and methods

Sie könnten beispielsweise eine Unterklasse „Pudel“ aus einer Klasse „Hund“ erstellen:

class Poodle(Dog):
    def show_trick(self):
        print("The poodle does a trick.")

Ein Poodle-Objekt hätte nun alle Attribute und Methoden der Dog-Klasse sowie eine eigene show_trick-Methode.

3. Kapselung

Bei der Kapselung werden Daten und Methoden, die mit diesen Daten arbeiten, in einer einzigen Einheit, in diesem Fall einem Objekt, verpackt. Dies fördert eine klare Trennung zwischen der internen Implementierung eines Objekts und seiner externen Schnittstelle.

Python verwendet Namensverzerrung, um eine Kapselung für Klassenmitglieder zu erreichen, indem dem Attributnamen ein doppelter Unterstrich vorangestellt wird, wodurch er scheinbar privat erscheint.

class Example:
    def __init__(self):
        self.__private_attribute = "I'm private!"

    def __private_method(self):
        print("You can't see me!")

Obwohl Sie in Python technisch gesehen immer noch auf diese privaten Member zugreifen können, wird davon dringend abgeraten, da dies gegen die Kapselungsprinzipien verstößt.

Durch das Verständnis und die Implementierung von Klassen, Vererbung und Kapselung in Ihren Python-Programmen können Sie die Leistungsfähigkeit und Flexibilität von OOP nutzen, um sauberen, modularen und wiederverwendbaren Code zu erstellen.

In unserem letzten Abschnitt des Cheatsheets stellen wir Ihnen eine Kurzreferenz für vier beliebte Python-Bibliotheken zur Verfügung.

4 hilfreiche Python-Bibliotheken

Mehrere Python-Bibliotheken können Ihnen dabei helfen, eine Vielzahl von Aufgaben zu erledigen oder Tools für verschiedene Themen wie Mathematik, Datenwissenschaft, Web Scraping usw. zu erhalten.

In diesem Abschnitt gehen wir kurz auf die folgenden Bibliotheken ein: NumPy , Pandas , Requests und Beautiful Soup .

1. NumPy

NumPy ist eine beliebte Python-Bibliothek für mathematisches und wissenschaftliches Rechnen. Mit seinem leistungsstarken N-dimensionalen Array-Objekt können Sie eine Vielzahl mathematischer Operationen verarbeiten, wie zum Beispiel:

• Grundlegende mathematische Funktionen

• Lineare Algebra

• Fourier-Analyse

• Zufallszahlengenerierung

Aufgrund der effizienten Array- Manipulationen eignet sich NumPy besonders für Projekte, die numerische Berechnungen erfordern.

2. Pandas

Pandas ist eine leistungsstarke Bibliothek zur Datenanalyse und -bearbeitung, die Sie für die Arbeit mit strukturierten Daten verwenden können. Auch in der Data-Science-Community erfreut es sich aufgrund der breiten Palette an Tools, die es für den Umgang mit Daten bietet, großer Beliebtheit.

Zu seinen Funktionen gehören:

• Datenstrukturen wie Series (1D) und DataFrame (2D)

• Datenbereinigung und -aufbereitung

• statistische Analyse

• Zeitreihenfunktionalität

Durch die Verwendung von Pandas können Sie Daten in verschiedenen Formaten wie CSV-, Excel- und SQL-Datenbanken problemlos importieren, analysieren und bearbeiten.

Wenn Sie sich für Pandas interessieren, können Sie sich unser Video ansehen, in dem erläutert wird, wie Sie mit Pandas Zeitreihendaten erneut abtasten, um die Analyse zu verbessern:

3. Anfragen

Die Requests- Bibliothek vereinfacht die Verarbeitung von HTTP-Anfragen in Python. Mit dieser Bibliothek können Sie problemlos HTTP-Anfragen wie GET, POST und DELETE senden und empfangen.

Zu den wichtigsten Funktionen gehören:

• Umgang mit Weiterleitungen und Verfolgen von Links auf Webseiten

• Hinzufügen von Headern, Formulardaten und Abfrageparametern über einfache Python-Bibliotheken

• Verwalten von Cookies und Sitzungen

Mithilfe von Requests können Sie schnell und effizient mit verschiedenen Webdiensten und APIs interagieren.

4. Schöne Suppe

Beautiful Soup ist eine Python-Bibliothek für Web Scraping, mit der Sie Daten aus HTML- und XML-Dokumenten extrahieren können. Zu den wichtigsten Funktionen gehören:

• Suche nach bestimmten Tags oder CSS-Klassen

• Navigieren und Ändern analysierter Bäume

• Extrahieren relevanter Informationen basierend auf Tag-Attributen

Durch die Verwendung von Beautiful Soup in Verbindung mit Requests können Sie leistungsstarke Web-Scraping-Anwendungen erstellen, die Informationen von einer Vielzahl von Websites sammeln.

Abschließende Gedanken

Und damit sind wir am Ende unserer kurzen Reise durch Python angelangt. Dieser Spickzettel ist Ihr Taschenführer, Ihr treuer Begleiter, wenn Sie schnell eine Erinnerung an die wichtigsten Funktionen und Befehle von Python benötigen.

Unsere Liste erhebt keinen Anspruch auf Vollständigkeit, ist aber ein solider Anfang, eine Grundlage, auf der Sie aufbauen können. Machen Sie also weiter, setzen Sie ein Lesezeichen, drucken Sie es aus, kleben Sie es an die Wand – achten Sie nur darauf, dass es beim Programmieren immer griffbereit ist. Viel Spaß beim Programmieren!