Python-Variablen und Datentypen

PythonPythonBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden Sie die grundlegenden Konzepte von Python-Variablen und Datentypen lernen. Variablen sind essentielle Bausteine in der Programmierung, die es Ihnen ermöglichen, Daten in Ihrem Code zu speichern, darauf zuzugreifen und sie zu manipulieren. Das Verständnis verschiedener Datentypen ist entscheidend für das Schreiben effektiver Python-Programme.

Sie werden verschiedene Variablen erstellen, die verschiedenen in Python verfügbaren Datentypen erkunden, Typkonvertierungen durchführen und lernen, wie Sie Variablen in Ausdrücken verwenden. Diese Fähigkeiten bilden die Grundlage der Python-Programmierung und sind für die Entwicklung komplexerer Anwendungen erforderlich.

Am Ende dieses Labs werden Sie es bequem finden, Variablen mit verschiedenen Datentypen in Python zu erstellen und zu verwenden.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python/BasicConceptsGroup -.-> python/variables_data_types("Variables and Data Types") python/BasicConceptsGroup -.-> python/numeric_types("Numeric Types") python/BasicConceptsGroup -.-> python/strings("Strings") python/BasicConceptsGroup -.-> python/booleans("Booleans") python/BasicConceptsGroup -.-> python/type_conversion("Type Conversion") python/ControlFlowGroup -.-> python/conditional_statements("Conditional Statements") subgraph Lab Skills python/variables_data_types -.-> lab-271605{{"Python-Variablen und Datentypen"}} python/numeric_types -.-> lab-271605{{"Python-Variablen und Datentypen"}} python/strings -.-> lab-271605{{"Python-Variablen und Datentypen"}} python/booleans -.-> lab-271605{{"Python-Variablen und Datentypen"}} python/type_conversion -.-> lab-271605{{"Python-Variablen und Datentypen"}} python/conditional_statements -.-> lab-271605{{"Python-Variablen und Datentypen"}} end

Erstellen Ihrer ersten Python-Variablen

In diesem Schritt werden Sie lernen, wie Sie Variablen in Python erstellen und verwenden. Variablen sind Container, die Datenwerte speichern und ihnen sinnvolle Namen geben, um sie im Code leichter referenzieren zu können.

Beginnen wir damit, eine neue Python-Datei zu erstellen und einige grundlegende Variablen zu definieren:

  1. Öffnen Sie die Datei /home/labex/project/variables.py in der WebIDE.

  2. Fügen Sie den folgenden Code hinzu, um drei Variablen zu definieren:

## Creating basic variables
water_supply = 100    ## Amount of water in gallons
food_supply = 50      ## Amount of food in pounds
ammunition = 40       ## Number of ammunition rounds

In Python erstellen Sie eine Variable, indem Sie einen Namen angeben, gefolgt vom Gleichheitszeichen (=) und dann dem Wert, den Sie ihr zuweisen möchten.

  1. Fügen wir nun Code hinzu, um die Werte dieser Variablen anzuzeigen:
## Displaying variable values
print("Water supply:", water_supply)
print("Food supply:", food_supply)
print("Ammunition:", ammunition)
  1. Führen Sie Ihr Skript aus, indem Sie im WebIDE ein Terminal öffnen und folgenden Befehl ausführen:
python3 /home/labex/project/variables.py

Sie sollten die folgende Ausgabe sehen:

Water supply: 100
Food supply: 50
Ammunition: 40

Herzlichen Glückwunsch. Sie haben Ihre ersten Python-Variablen erstellt und ihre Werte angezeigt. Diese Variablen speichern Informationen, auf die Ihr Programm zugreifen und sie manipulieren kann.

Verständnis numerischer Datentypen

Python verfügt über mehrere Datentypen, die verwendet werden, um verschiedene Arten von Daten zu klassifizieren. In diesem Schritt werden Sie zwei numerische Datentypen kennenlernen: Ganzzahlen (Integers) und Fließkommazahlen (Floats).

  1. Öffnen Sie die Datei /home/labex/project/variables.py in der WebIDE.

  2. Fügen Sie den folgenden Code zur Datei hinzu, um Variablen mit verschiedenen numerischen Datentypen zu definieren:

## Numeric data types
integer_value = 42        ## Integer (whole number)
float_value = 3.14159     ## Float (decimal number)
  1. Untersuchen wir die Typen dieser Variablen mit der Funktion type():
## Check the data types
print("\nUnderstanding data types:")
print("integer_value:", integer_value, "- Type:", type(integer_value))
print("float_value:", float_value, "- Type:", type(float_value))
  1. Führen wir nun einige grundlegende Operationen mit diesen numerischen Typen aus:
## Basic operations with numbers
sum_result = integer_value + float_value
product_result = integer_value * float_value

print("\nBasic operations:")
print(f"{integer_value} + {float_value} = {sum_result}")
print(f"{integer_value} * {float_value} = {product_result}")
  1. Führen Sie Ihr Skript aus:
python3 /home/labex/project/variables.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

Beachten Sie, dass Python bei der Ausführung von Operationen mit Ganzzahlen und Fließkommazahlen das Ergebnis bei Bedarf automatisch in eine Fließkommazahl umwandelt.

Arbeiten mit Strings und Booleans

Neben numerischen Datentypen bietet Python Strings für Textdaten und Booleans für Wahrheitswerte (true/false). Lassen Sie uns diese Typen untersuchen:

  1. Öffnen Sie die Datei /home/labex/project/variables.py in der WebIDE.

  2. Fügen Sie den folgenden Code hinzu, um String- und Boolean-Variablen zu definieren:

## String data type - for text
camp_name = "Python Base Camp"
location = 'Programming Valley'  ## Strings can use single or double quotes

## Boolean data type - for true/false values
is_safe = True
has_water = True
enemy_nearby = False
  1. Fügen Sie Code hinzu, um diese Variablen zu überprüfen und anzuzeigen:
## Displaying string and boolean variables
print("\nString variables:")
print("Camp name:", camp_name, "- Type:", type(camp_name))
print("Location:", location, "- Type:", type(location))

print("\nBoolean variables:")
print("Is the camp safe?", is_safe, "- Type:", type(is_safe))
print("Is water available?", has_water, "- Type:", type(has_water))
print("Is enemy nearby?", enemy_nearby, "- Type:", type(enemy_nearby))
  1. Lassen Sie uns auch einige String-Operationen demonstrieren:
## String operations
full_location = camp_name + " in " + location
print("\nFull location:", full_location)

## String repetition
border = "-" * 20
print(border)
print("Camp Information")
print(border)
  1. Führen Sie Ihr Skript aus:
python3 /home/labex/project/variables.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

String variables:
Camp name: Python Base Camp - Type: <class 'str'>
Location: Programming Valley - Type: <class 'str'>

Boolean variables:
Is the camp safe? True - Type: <class 'bool'>
Is water available? True - Type: <class 'bool'>
Is enemy nearby? False - Type: <class 'bool'>

Full location: Python Base Camp in Programming Valley
--------------------
Camp Information
--------------------

Beachten Sie, wie Strings mit dem +-Operator verkettet und mit dem *-Operator wiederholt werden können. Booleans sind nützlich, um Bedingungen darzustellen und den Programmfluss zu steuern.

Typkonvertierung und Typüberprüfung

Manchmal müssen Sie Werte von einem Datentyp in einen anderen umwandeln oder den Datentyp einer Variablen überprüfen. Dies wird Typkonvertierung (oder Typumwandlung, engl. type casting) genannt. Lassen Sie uns dieses Konzept untersuchen:

  1. Öffnen Sie die Datei /home/labex/project/variables.py in der WebIDE.

  2. Fügen Sie Code hinzu, um die Typkonvertierung zu demonstrieren:

## Type conversion examples
print("\nType Conversion Examples:")

## Converting string to integer
supplies_str = "75"
supplies_int = int(supplies_str)
print(f"String '{supplies_str}' converted to integer: {supplies_int} - Type: {type(supplies_int)}")

## Converting integer to string
days_int = 30
days_str = str(days_int)
print(f"Integer {days_int} converted to string: '{days_str}' - Type: {type(days_str)}")

## Converting integer to float
distance_int = 100
distance_float = float(distance_int)
print(f"Integer {distance_int} converted to float: {distance_float} - Type: {type(distance_float)}")

## Converting float to integer (note: this truncates the decimal part)
temperature_float = 32.7
temperature_int = int(temperature_float)
print(f"Float {temperature_float} converted to integer: {temperature_int} - Type: {type(temperature_int)}")
  1. Fügen Sie Code hinzu, um die Datentypen zu überprüfen:
## Type checking
print("\nType Checking Examples:")
value1 = 42
value2 = "42"
value3 = 42.0

print(f"Is {value1} an integer? {isinstance(value1, int)}")
print(f"Is {value2} an integer? {isinstance(value2, int)}")
print(f"Is {value3} a float? {isinstance(value3, float)}")
print(f"Is {value2} a string? {isinstance(value2, str)}")
  1. Führen Sie Ihr Skript aus:
python3 /home/labex/project/variables.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

...previous output...

Type Conversion Examples:
String '75' converted to integer: 75 - Type: <class 'int'>
Integer 30 converted to string: '30' - Type: <class 'str'>
Integer 100 converted to float: 100.0 - Type: <class 'float'>
Float 32.7 converted to integer: 32 - Type: <class 'int'>

Type Checking Examples:
Is 42 an integer? True
Is 42 an integer? False
Is 42.0 a float? True
Is 42 a string? True

Beachten Sie Folgendes:

  • int() wandelt Werte in Ganzzahlen (Integers) um.
  • float() wandelt Werte in Fließkommazahlen (Floats) um.
  • str() wandelt Werte in Strings um.
  • Beim Umwandeln einer Fließkommazahl in eine Ganzzahl wird der Dezimalteil abgeschnitten (nicht gerundet).
  • Die Funktion isinstance() überprüft, ob eine Variable einen bestimmten Datentyp hat.

Diese Konvertierungsfunktionen sind nützlich, wenn Sie Benutzereingaben verarbeiten müssen oder mit Daten aus verschiedenen Quellen arbeiten.

Variablen in Ausdrücken und Entscheidungsfindung

Variablen werden erst richtig leistungsfähig, wenn sie in Ausdrücken und Entscheidungsstrukturen verwendet werden. Lassen Sie uns untersuchen, wie man Variablen in Berechnungen und bedingten Anweisungen einsetzt:

  1. Öffnen Sie die Datei /home/labex/project/variables.py in der WebIDE.

  2. Fügen Sie Code hinzu, um die Verwendung von Variablen in Berechnungen zu demonstrieren:

## Variables in expressions
print("\nVariables in Expressions:")

water_per_day = 4  ## gallons
food_per_day = 2.5  ## pounds

## Calculate how long supplies will last
water_days = water_supply / water_per_day
food_days = food_supply / food_per_day

print(f"With {water_supply} gallons of water, consuming {water_per_day} gallons per day, water will last {water_days} days")
print(f"With {food_supply} pounds of food, consuming {food_per_day} pounds per day, food will last {food_days} days")
  1. Fügen Sie Code hinzu, um die Verwendung von Variablen in bedingten Anweisungen zu demonstrieren:
## Using variables for decision making
print("\nDecision Making with Variables:")

## Check which supply will run out first
if water_days < food_days:
    limiting_factor = "Water"
    limiting_days = water_days
else:
    limiting_factor = "Food"
    limiting_days = food_days

print(f"{limiting_factor} will run out first, after {limiting_days} days")

## Check if supplies are sufficient for a 10-day journey
journey_days = 10
sufficient_supplies = water_days >= journey_days and food_days >= journey_days and ammunition >= 20

print(f"Planning a {journey_days}-day journey.")
print(f"Do we have sufficient supplies? {sufficient_supplies}")

## Provide specific supply status
if water_days < journey_days:
    print(f"Warning: Water will only last {water_days:.1f} days.")
if food_days < journey_days:
    print(f"Warning: Food will only last {food_days:.1f} days.")
if ammunition < 20:
    print(f"Warning: Only {ammunition} rounds of ammunition available.")
  1. Führen Sie Ihr Skript aus:
python3 /home/labex/project/variables.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

...previous output...

Variables in Expressions:
With 100 gallons of water, consuming 4 gallons per day, water will last 25.0 days
With 50 pounds of food, consuming 2.5 pounds per day, food will last 20.0 days

Decision Making with Variables:
Food will run out first, after 20.0 days
Planning a 10-day journey.
Do we have sufficient supplies? True

Dies zeigt, wie man Variablen in mathematischen Berechnungen verwenden kann und wie man Entscheidungen auf der Grundlage von Variablenwerten trifft. Beachten Sie, wie wir Vergleichsoperatoren (<, >=) und logische Operatoren (and) verwenden, um Bedingungen zu erstellen.

Die Formatierungssyntax {water_days:.1f} gibt an, dass die Fließkommazahl mit einer Dezimalstelle angezeigt werden soll.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Konzepte von Python-Variablen und Datentypen gelernt. Sie haben Variablen verschiedener Typen erstellt und verwendet, darunter:

  • Ganzzahlen (Integers) für ganze Zahlen
  • Fließkommazahlen (Floats) für Dezimalzahlen
  • Zeichenketten (Strings) für Textdaten
  • Boolesche Werte (Booleans) für Wahrheitswerte (wahr/falsch)

Sie haben auch gelernt, wie man:

  • Den Typ einer Variablen mit der Funktion type() überprüft
  • Zwischen verschiedenen Datentypen mit Funktionen wie int(), float() und str() konvertiert
  • Variablen in Ausdrücken und Berechnungen verwendet
  • Entscheidungen auf der Grundlage von Variablenwerten mit bedingten Anweisungen trifft

Diese Konzepte bilden die Grundlage der Python-Programmierung. Variablen ermöglichen es Ihnen, Daten zu speichern und zu manipulieren, während das Verständnis verschiedener Datentypen Ihnen hilft, den richtigen Typ für jede Situation zu verwenden. Wenn Sie Ihre Python-Reise fortsetzen, werden Sie auf diesen Grundlagen aufbauen, um komplexere und leistungsfähigere Programme zu erstellen.