Wie man in Python eine Liste mit einem Zahlenbereich erstellt

Einführung

Python-Listen sind vielseitige Datenstrukturen, die eine Vielzahl von Elementen, einschließlich Zahlen, speichern können. In diesem Tutorial lernen Sie, wie Sie in Python eine Liste mit einer Reihe von Zahlen erstellen können, was für verschiedene Programmieraufgaben eine nützliche Technik sein kann. Wir werden Methoden untersuchen, um Listen mit Zahlenfolgen zu generieren, und besprechen, wie Sie diese Listen mit Zahlenbereichen effektiv in Ihren Python-Programmen einsetzen können.

Skills Graph

Erstellen und Verstehen von Python-Listen

Python-Listen sind eine der am häufigsten verwendeten Datenstrukturen, die es Ihnen ermöglichen, mehrere Elemente in einer einzigen Variablen zu speichern. Bevor wir uns dem Erstellen von Listen mit Zahlenbereichen widmen, lassen Sie uns die Grundlagen von Python-Listen verstehen.

Zunächst erstellen wir eine neue Python-Datei, um damit zu arbeiten. Im WebIDE:

1. Klicken Sie auf das Menü "File" oben.
2. Wählen Sie "New File" aus.
3. Benennen Sie die Datei python_lists.py.
4. Speichern Sie sie im Verzeichnis /home/labex/project.

Jetzt schreiben wir etwas Code, um zu verstehen, wie Python-Listen funktionieren:

## Basic list creation
numbers = [1, 2, 3, 4, 5]
print("Basic list:", numbers)

## Lists can contain different data types
mixed_list = [1, "hello", 3.14, True]
print("Mixed data types:", mixed_list)

## Accessing list elements (indexing starts at 0)
print("First element:", numbers[0])
print("Last element:", numbers[4])

## Getting the length of a list
print("List length:", len(numbers))

## Modifying list elements
numbers[2] = 30
print("Modified list:", numbers)

## Adding elements to a list
numbers.append(6)
print("After append:", numbers)

## Removing elements from a list
numbers.remove(30)
print("After remove:", numbers)

Lassen Sie uns dieses Skript ausführen, um die Ausgabe zu sehen. Im Terminal:

1. Stellen Sie sicher, dass Sie sich im Verzeichnis /home/labex/project befinden.
2. Führen Sie den folgenden Befehl aus:

python3 python_lists.py

Sie sollten die folgende Ausgabe sehen:

Basic list: [1, 2, 3, 4, 5]
Mixed data types: [1, 'hello', 3.14, True]
First element: 1
Last element: 5
List length: 5
Modified list: [1, 2, 30, 4, 5]
After append: [1, 2, 30, 4, 5, 6]
After remove: [1, 2, 4, 5, 6]

Wie Sie sehen können, haben Python-Listen mehrere wichtige Eigenschaften:

• Listen sind geordnete Sammlungen, d. h. die Elemente haben eine definierte Reihenfolge.
• Listen sind veränderlich (mutable), sodass Sie Elemente nach der Erstellung ändern, hinzufügen oder entfernen können.
• Listen können Elemente unterschiedlicher Datentypen enthalten.
• Jedes Element in einer Liste kann über seinen Index (Position) zugegriffen werden.

Nachdem wir die Grundlagen von Python-Listen verstanden haben, können wir uns nun dem Erstellen von Listen mit Zahlenbereichen zuwenden.

Erstellen von Listen mit der range()-Funktion

Die range()-Funktion in Python ist eine eingebaute Funktion, die eine Sequenz von Zahlen generiert. Sie wird häufig in Verbindung mit der list()-Funktion verwendet, um Listen mit Zahlenbereichen zu erstellen.

Erstellen wir eine neue Python-Datei, um die range()-Funktion zu erkunden:

1. Klicken Sie auf das Menü "File" oben.
2. Wählen Sie "New File" aus.
3. Benennen Sie die Datei range_lists.py.
4. Speichern Sie sie im Verzeichnis /home/labex/project.

Jetzt fügen wir Code hinzu, um verschiedene Verwendungsmöglichkeiten der range()-Funktion zu erkunden:

## Basic usage of range() function
## Note: range() returns a range object, not a list directly
## We convert it to a list to see all values at once

## range(stop) - generates numbers from 0 to stop-1
numbers1 = list(range(5))
print("range(5):", numbers1)

## range(start, stop) - generates numbers from start to stop-1
numbers2 = list(range(2, 8))
print("range(2, 8):", numbers2)

## range(start, stop, step) - generates numbers from start to stop-1 with step
numbers3 = list(range(1, 10, 2))
print("range(1, 10, 2):", numbers3)

## Creating a list of descending numbers
numbers4 = list(range(10, 0, -1))
print("range(10, 0, -1):", numbers4)

## Creating even numbers from 2 to 10
even_numbers = list(range(2, 11, 2))
print("Even numbers:", even_numbers)

## Creating odd numbers from 1 to 9
odd_numbers = list(range(1, 10, 2))
print("Odd numbers:", odd_numbers)

Lassen Sie uns dieses Skript ausführen, um die Ergebnisse zu sehen:

python3 range_lists.py

Sie sollten die folgende Ausgabe sehen:

range(5): [0, 1, 2, 3, 4]
range(2, 8): [2, 3, 4, 5, 6, 7]
range(1, 10, 2): [1, 3, 5, 7, 9]
range(10, 0, -1): [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Even numbers: [2, 4, 6, 8, 10]
Odd numbers: [1, 3, 5, 7, 9]

Die range()-Funktion kann auf drei verschiedene Arten verwendet werden:

1. range(stop): Generiert Zahlen von 0 bis stop-1.
2. range(start, stop): Generiert Zahlen von start bis stop-1.
3. range(start, stop, step): Generiert Zahlen von start bis stop-1 mit einem Schritt von step.

Indem Sie diese verschiedenen Formen verstehen, können Sie verschiedene Arten von Zahlenfolgen erstellen:

• Aufsteigende Zahlen (Aufzählung)
• Absteigende Zahlen (Abzählung)
• Gerade Zahlen
• Ungerade Zahlen
• Zahlen mit benutzerdefinierten Intervallen

Denken Sie daran, dass die range()-Funktion selbst ein range-Objekt zurückgibt, das speichereffizient ist. Wir konvertieren es mit der list()-Funktion in eine Liste, um alle Werte auf einmal zu sehen oder Listenoperationen darauf auszuführen.

Verwenden von List Comprehensions mit range

Python bietet eine leistungsstarke Funktion namens List Comprehensions (Listen-Abstraktionen), die es Ihnen ermöglicht, Listen auf eine kompakte und lesbare Weise zu erstellen. In Kombination mit der range()-Funktion bieten List Comprehensions eine elegante Lösung für das Erstellen von Listen mit bestimmten Mustern.

Erstellen wir eine neue Python-Datei, um List Comprehensions zu erkunden:

1. Klicken Sie auf das Menü "File" oben.
2. Wählen Sie "New File" aus.
3. Benennen Sie die Datei list_comprehensions.py.
4. Speichern Sie sie im Verzeichnis /home/labex/project.

Jetzt fügen wir Code hinzu, um zu erkunden, wie List Comprehensions mit Zahlenbereichen funktionieren:

## Basic list comprehension with range
## Format: [expression for item in iterable]
squares = [x**2 for x in range(1, 6)]
print("Squares of numbers 1-5:", squares)

## List comprehension with condition
## Format: [expression for item in iterable if condition]
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print("Squares of even numbers 1-10:", even_squares)

## Creating a list of numbers divisible by 3
divisible_by_3 = [x for x in range(1, 31) if x % 3 == 0]
print("Numbers divisible by 3 (1-30):", divisible_by_3)

## Converting Celsius temperatures to Fahrenheit
celsius_temps = list(range(0, 101, 20))
fahrenheit_temps = [(c * 9/5) + 32 for c in celsius_temps]

print("Celsius temperatures:", celsius_temps)
print("Fahrenheit temperatures:", [round(f, 1) for f in fahrenheit_temps])

## Creating a list of tuples (number, square)
number_pairs = [(x, x**2) for x in range(1, 6)]
print("Numbers with their squares:")
for num, square in number_pairs:
    print(f"Number: {num}, Square: {square}")

Lassen Sie uns dieses Skript ausführen, um die Ergebnisse zu sehen:

python3 list_comprehensions.py

Sie sollten die folgende Ausgabe sehen:

Squares of numbers 1-5: [1, 4, 9, 16, 25]
Squares of even numbers 1-10: [4, 16, 36, 64, 100]
Numbers divisible by 3 (1-30): [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
Celsius temperatures: [0, 20, 40, 60, 80, 100]
Fahrenheit temperatures: [32.0, 68.0, 104.0, 140.0, 176.0, 212.0]
Numbers with their squares:
Number: 1, Square: 1
Number: 2, Square: 4
Number: 3, Square: 9
Number: 4, Square: 16
Number: 5, Square: 25

List Comprehensions haben eine kompakte Syntax, die es Ihnen ermöglicht, Listen in einer einzigen Codezeile zu erstellen. Die allgemeine Syntax lautet:

[expression for item in iterable if condition]

Dabei gilt:

• expression ist das, was Sie in die neue Liste aufnehmen möchten.
• item ist jedes Element aus der iterierbaren Sequenz.
• iterable ist die Sequenz, durch die Sie iterieren (z. B. range()).
• if condition ist optional und filtert, welche Elemente aufgenommen werden.

List Comprehensions sind lesbarer und oft effizienter als das Erstellen einer Liste mit einer herkömmlichen for-Schleife und der append()-Methode. Sie sind besonders nützlich in Kombination mit der range()-Funktion für das Erstellen von numerischen Listen mit bestimmten Mustern oder Transformationen.

Praktische Anwendungen von Listen mit Zahlenbereichen

Nachdem wir gelernt haben, wie man Listen mit Zahlenbereichen erstellt, wollen wir einige praktische Anwendungen erkunden. Diese Beispiele werden zeigen, wie Listen mit Zahlenbereichen eingesetzt werden können, um häufige Programmierprobleme zu lösen.

Erstellen wir eine neue Python-Datei für unsere praktischen Beispiele:

1. Klicken Sie auf das Menü "File" oben.
2. Wählen Sie "New File" aus.
3. Benennen Sie die Datei range_applications.py.
4. Speichern Sie sie im Verzeichnis /home/labex/project.

Jetzt fügen wir Code für mehrere praktische Anwendungen hinzu:

## Example 1: Sum of numbers from 1 to 100
total = sum(range(1, 101))
print(f"Sum of numbers from 1 to 100: {total}")

## Example 2: Creating a multiplication table
def print_multiplication_table(n):
    print(f"\nMultiplication table for {n}:")
    for i in range(1, 11):
        result = n * i
        print(f"{n} × {i} = {result}")

print_multiplication_table(7)

## Example 3: Generating a calendar of years
current_year = 2023
years = list(range(current_year - 5, current_year + 6))
print(f"\nYears (5 past to 5 future): {years}")

## Example 4: Creating a countdown timer
def countdown(seconds):
    print("\nCountdown:")
    for i in range(seconds, 0, -1):
        print(i, end=" ")
    print("Blast off!")

countdown(10)

## Example 5: Calculating factorial
def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

num = 5
print(f"\nFactorial of {num}: {factorial(num)}")

## Example 6: Creating a simple number guessing game
import random

def number_guessing_game():
    ## Generate a random number between 1 and 100
    secret_number = random.randint(1, 100)
    attempts = list(range(1, 11))  ## Maximum 10 attempts

    print("\nNumber Guessing Game")
    print("I'm thinking of a number between 1 and 100.")
    print("You have 10 attempts to guess it.")

    for attempt in attempts:
        ## In a real game, we would get user input
        ## For demonstration, we'll just print the logic
        print(f"\nAttempt {attempt}")
        print(f"(If this were interactive, you would guess a number here)")
        print(f"The secret number is: {secret_number}")

        ## Break after the first attempt for demonstration purposes
        break

number_guessing_game()

Lassen Sie uns dieses Skript ausführen, um die Ergebnisse zu sehen:

python3 range_applications.py

Sie sollten eine Ausgabe sehen, die jede der praktischen Anwendungen demonstriert:

1. Die Summe aller Zahlen von 1 bis 100
2. Eine Multiplikationstabelle für die Zahl 7
3. Eine Liste von Jahren (5 vergangene Jahre bis 5 zukünftige Jahre)
4. Eine Countdown-Zählung von 10 bis 1
5. Die Fakultät von 5
6. Eine Demonstration, wie ein Zahlen-Ratsspiel funktionieren könnte

Diese Beispiele zeigen, wie Zahlenbereiche in Kombination mit Listen eingesetzt werden können, um verschiedene Programmierprobleme effizient zu lösen. Einige wichtige Vorteile der Verwendung von Listen mit Zahlenbereichen in Ihren Programmen sind:

1. Vereinfachter Code für das Iterieren über eine Sequenz von Zahlen
2. Effiziente Speicherausnutzung (range-Objekte speichern nicht alle Zahlen im Speicher)
3. Einfache Erstellung von numerischen Mustern und Sequenzen
4. Bequeme Integration mit anderen Python-Funktionen wie sum(), min() und max()

Durch das Beherrschen der Erstellung und Manipulation von Listen mit Zahlenbereichen können Sie kompakteren und effizienteren Python-Code für eine Vielzahl von Anwendungen schreiben.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man in Python Listen mit Zahlenbereichen erstellt und verwendet. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

1. Sie haben die Grundlagen von Python-Listen gelernt, einschließlich der Erstellung, des Zugriffs auf und die Modifikation von Listen.
2. Sie haben die range()-Funktion untersucht und gelernt, wie man sie zur Erzeugung von Zahlenfolgen verwendet.
3. Sie haben entdeckt, wie man List Comprehensions (Listen-Abstraktionen) einsetzt, um komplexere Listen auf der Grundlage von Zahlenbereichen zu erstellen.
4. Sie haben diese Techniken angewendet, um praktische Programmierprobleme zu lösen.

Diese Fähigkeiten sind für viele Python-Programmieraufgaben von grundlegender Bedeutung, von einfacher Datenverarbeitung bis hin zu komplexeren Algorithmen. Die Fähigkeit, schnell Zahlenfolgen zu generieren und zu manipulieren, ist ein leistungsstarkes Werkzeug, das Ihnen helfen wird, effizienteren und effektiveren Python-Code zu schreiben.

Wenn Sie Ihre Python-Reise fortsetzen, werden Sie diese Techniken in vielen Kontexten nützlich finden, einschließlich Datenanalyse, Webentwicklung, wissenschaftlicher Rechnungen und vieles mehr. Die Kombination von Listen und der range()-Funktion bildet eine solide Grundlage für die Arbeit mit numerischen Daten in Python.