Die Python-Lernkurve: Vom Python-Neuling zum Python-Profi

Einführung:

Python ist eine der vielseitigsten und am weitesten verbreiteten Programmiersprachen der Welt und bekannt für ihre Einfachheit, Lesbarkeit und Vielseitigkeit. In diesem Artikel werden wir eine Reihe von Beispielszenarien untersuchen, in denen Code von Programmierern mit drei unterschiedlichen Kompetenzniveaus entwickelt wird: Anfänger, Fortgeschrittener und Experte.

Fortgeschrittene und Experten verwenden normalerweise Folgendes:

• Listenverständnis: Eine prägnante Möglichkeit, Listen mit einer einzigen Codezeile zu erstellen.

squares = [x**2 for x in range(1, 6)]
print(squares)  
# Output: [1, 4, 9, 16, 25]

squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)  
# Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

nums = [1, 2, 3, 4, 5]
doubles = list(map(lambda x: x * 2, nums))
print(doubles)  # Output: [2, 4, 6, 8, 10]

def greet_decorator(func):
    def wrapper():
        print("Hello!")
        func()
        print("Welcome!")
    return wrapper

@greet_decorator
def greet_name():
    print("John")

greet_name()
# Output:
# Hello!
# John
# Welcome!

with open("file.txt", "r") as file:
    content = file.read()
    print(content)

from typing import List

def sum_elements(elements: List[int]) -> int:
    return sum(elements)

result = sum_elements([1, 2, 3, 4, 5])
print(result)  # Output: 15

def fibonacci_gen(n: int):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci_gen(5):
    print(num, end=" ")
# Output: 0 1 1 2 3

import re

text = "The email addresses are [email protected] and [email protected]"
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(pattern, text)
print(emails)  # Output: ['[email protected]', '[email protected]']

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"An error occurred: {e}")
# Output: An error occurred: division by zero

# Importing the 'math' module and using its 'sqrt' function
import math

sqrt_result = math.sqrt(25)
print(sqrt_result)  # Output: 5.0

import threading

def print_square(num):
    print(f"Square: {num * num}")

def print_cube(num):
    print(f"Cube: {num * num * num}")

thread1 = threading.Thread(target=print_square, args=(4,))
thread2 = threading.Thread(target=print_cube, args=(4,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

# Output:
# Square: 16
# Cube: 64

# Built-in functions
numbers = [2, 4, 1, 6, 3, 8, 5, 7]
max_num = max(numbers)  # Find the maximum number in the list
min_num = min(numbers)  # Find the minimum number in the list
sorted_nums = sorted(numbers)  # Sort the list in ascending order
reversed_nums = list(reversed(numbers))  # Reverse the list

print("Maximum number:", max_num)
print("Minimum number:", min_num)
print("Sorted numbers:", sorted_nums)
print("Reversed numbers:", reversed_nums)

# Standard library modules
from collections import Counter
from itertools import combinations

# Counter (from collections module)
word = "mississippi"
counter = Counter(word)  # Count the occurrences of each character
print("Character count:", counter)

# Combinations (from itertools module)
combos = list(combinations(numbers, 2))  # Find all combinations of size 2
print("Combinations of size 2:", combos)

• PEP 8 und Codierungsstil: Einhaltung des offiziellen Python-Styleguides (PEP 8) und anderer Best Practices für die Lesbarkeit und Konsistenz des Codes.

# PEP 8 compliant code snippet

def calculate_area(radius):
    """Calculate the area of a circle given its radius.

    Args:
        radius (float): The radius of the circle.

    Returns:
        float: The area of the circle.
    """
    pi = 3.14159
    return pi * radius**2


def main():
    # Collect user input for the radius
    radius = float(input("Enter the radius of the circle: "))

    # Calculate the area using the defined function
    area = calculate_area(radius)

    # Display the result with appropriate formatting
    print(f"The area of the circle with radius {radius} is {area:.2f}")


if __name__ == "__main__":
    main()

import unittest

def add_numbers(a, b):
    return a + b

class TestAddition(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add_numbers(2, 3), 5)

if __name__ == '__main__':
    unittest.main(argv=['first-arg-is-ignored'], exit=False)
# Output: .
# ----------------------------------------------------------------------
# Ran 1 test in 0.002s
#
# OK

Anfänger:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_sum = 0

for num in numbers:
    if num % 2 == 0:
        even_sum += num

print("The sum of even numbers is:", even_sum)

• Überprüft, ob eine Zahl gerade ist, indem der Moduloperator verwendet wird
• Fügt die gerade Zahl zur Summenvariablen hinzu

def is_even(num):
    return num % 2 == 0

def even_sum(numbers):
    result = 0
    for num in numbers:
        if is_even(num):
            result += num
    return result

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = even_sum(numbers)
print("The sum of even numbers is:", result)

• Erstellt eine Funktion even_sumzur Berechnung der Summe gerader Zahlen
• Der Code ist modularer und einfacher zu warten

def even_sum(numbers):
    return sum(filter(lambda num: num % 2 == 0, numbers))

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = even_sum(numbers)
print("The sum of even numbers is:", result)

• Verwendet eine Lambda-Funktion zum präzisen und effizienten Filtern gerader Zahlen
• Der Code ist kompakter und nutzt die funktionalen Programmierfunktionen von Python

Anfänger:

text = "hello world"
char_count = {}

for char in text:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1

print("Character counts:", char_count)

#Character counts: {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

• Überprüft, ob ein Zeichen bereits im Wörterbuch vorhanden ist, und aktualisiert die Anzahl entsprechend.

def count_characters(text):
    char_count = {}
    for char in text:
        char_count[char] = char_count.get(char, 0) + 1
    return char_count

text = "hello world"
result = count_characters(text)
print("Character counts:", result)

• Verwendet die dict.get()Methode, um den Code zu vereinfachen.

from collections import Counter

def count_characters(text):
    return Counter(text)

text = "hello world"
result = count_characters(text)
print("Character counts:", result)

• Nutzt die integrierte Funktion Counter, um Zeichenvorkommen effizient zu zählen.

Anfänger:

numbers = [1, 2, 3, 4, 5]
total = 0

for num in numbers:
    total += num

average = total / len(numbers)
print("The average is:", average)

• Dividiert die Summe durch die Länge der Liste, um den Durchschnitt zu berechnen

def calculate_average(numbers):
    return sum(numbers) / len(numbers)

numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print("The average is:", average)

• Verwendet die integrierte sumFunktion, um den Code zu vereinfachen

from statistics import mean

def calculate_average(numbers):
    return mean(numbers)

numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print("The average is:", average)

• Nutzt die integrierte meanFunktion, um den Durchschnitt zu berechnen

Anfänger:

text = "hello"
reversed_text = ""

for char in text:
    reversed_text = char + reversed_text

print("Reversed text:", reversed_text)
#text = "Hello"
#Reversed text: olleH

• Verkettet Zeichen in umgekehrter Reihenfolge, um die umgekehrte Zeichenfolge zu erstellen

def reverse_string(text):
    return "".join(reversed(text))

text = "hello"
reversed_text = reverse_string(text)
print("Reversed text:", reversed_text)

• Verwendet die reversedFunktion und joinMethode, um die Zeichenfolge umzukehren

def reverse_string(text):
    return text[::-1]

text = "hello"
reversed_text = reverse_string(text)
print("Reversed text:", reversed_text)

5. Finden der größten Zahl in einer Liste:

Anfänger:

numbers = [1, 3, 7, 2, 5]
max_number = numbers[0]

for num in numbers:
    if num > max_number:
        max_number = num

print("The largest number is:", max_number)

#The largest number is: 7

• Vergleicht jede Zahl mit dem aktuellen Maximum und aktualisiert das Maximum entsprechend

def find_max(numbers):
    return max(numbers)

numbers = [1, 3, 7, 2, 5]
max_number = find_max(numbers)
print("The largest number is:", max_number)

• Verwendet die integrierte maxFunktion, um die maximale Anzahl zu ermitteln

from functools import reduce

def find_max(numbers):
    return reduce(lambda x, y: x if x > y else y, numbers)

numbers = [1, 3, 7, 2, 5]
max_number = find_max(numbers)
print("The largest number is:", max_number)

• Nutzt die reduceFunktion mit einer Lambda-Funktion, um die maximale Anzahl zu ermitteln

Anfänger:

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = []

for item in original_list:
    if item not in unique_list:
        unique_list.append(item)

print("Unique list:", unique_list)

• Überprüft, ob ein Element nicht in der eindeutigen Liste enthalten ist, und hängt es an, wenn es nicht vorhanden ist

def remove_duplicates(items):
    return list(set(items))

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = remove_duplicates(original_list)
print("Unique list:", unique_list)

• Verwendet die integrierte setDatenstruktur, um Duplikate zu entfernen und wandelt sie wieder in eine Liste um

def remove_duplicates(items):
    return list(dict.fromkeys(items))

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = remove_duplicates(original_list)
print("Unique list:", unique_list)

7. Quadrieren aller Zahlen in einer Liste:

Anfänger:

numbers = [1, 2, 3, 4, 5]
squared_numbers = []

for num in numbers:
    squared_numbers.append(num ** 2)

print("Squared numbers:", squared_numbers)
#Squared numbers: [1, 4, 9, 16, 25]

• Hängt das Quadrat jeder Zahl an die Liste der quadrierten Zahlen an

def square_numbers(numbers):
    return [num ** 2 for num in numbers]

numbers = [1, 2, 3, 4, 5]
squared_numbers = square_numbers(numbers)
print("Squared numbers:", squared_numbers)

• Verwendet das Listenverständnis, um die Liste mit quadrierten Zahlen zu erstellen

def square_numbers(numbers):
    return list(map(lambda x: pow(x, 2), numbers))

numbers = [1, 2, 3, 4, 5]
squared_numbers = square_numbers(numbers)
print("Squared numbers:", squared_numbers)

      
                

                    
                    
                
            

Anfänger:

numbers = [1, 2, 3, 4, 5]
positions = 2

rotated_list = numbers[-positions:] + numbers[:-positions]
print("Rotated list:", rotated_list)
#Rotated list: [4, 5, 1, 2, 3]

Dazwischenliegend:

def rotate_list(numbers, positions):
    return numbers[-positions:] + numbers[:-positions]

numbers = [1, 2, 3, 4, 5]
positions = 2
rotated_list = rotate_list(numbers, positions)
print("Rotated list:", rotated_list)

• Verwendet die Slicing-Syntax von Python, um die Liste um die angegebene Anzahl von Positionen zu drehen

from collections import deque

def rotate_list(numbers, positions):
    rotated_numbers = deque(numbers)
    rotated_numbers.rotate(positions)
    return list(rotated_numbers)

numbers = [1, 2, 3, 4, 5]
positions = 2
rotated_list = rotate_list(numbers, positions)
print("Rotated list:", rotated_list)

• Nutzt die dequeKlasse und ihre rotateMethode, um die Liste effizient um die angegebene Anzahl von Positionen zu rotieren

Anfänger:

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = []

for num in list1:
    if num in list2:
        common_elements.append(num)

print("Common elements:", common_elements)
#Common elements: [4, 5]

• Prüft, ob ein Element in der zweiten Liste vorhanden ist, und hängt es an die Liste der gemeinsamen Elemente an, wenn es gefunden wird

def find_common_elements(list1, list2):
    return [num for num in list1 if num in list2]

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = find_common_elements(list1, list2)
print("Common elements:", common_elements)

• Verwendet Listenverständnis, um eine Liste gemeinsamer Elemente zu erstellen

def find_common_elements(list1, list2):
    return list(set(list1) & set(list2))

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = find_common_elements(list1, list2)
print("Common elements:", common_elements)

• Konvertiert das Ergebnis zurück in eine Liste

Anfänger:

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

transposed_matrix = []

for i in range(len(matrix[0])):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed_matrix.append(transposed_row)

print("Transposed matrix:", transposed_matrix)

• Fügt die Elemente aus jeder Zeile in der ursprünglichen Matrix hinzu, um die transponierte Matrix zu erstellen

def transpose_matrix(matrix):
    return [[row[i] for row in matrix] for i in range(len(matrix[0]))]

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
transposed_matrix = transpose_matrix(matrix)
print("Transposed matrix:", transposed_matrix)

• Verwendet das Verständnis verschachtelter Listen, um die transponierte Matrix zu erstellen

def transpose_matrix(matrix):
    return list(zip(*matrix))

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
transposed_matrix = transpose_matrix(matrix)
print("Transposed matrix:", transposed_matrix)

11. Prüfen, ob eine Zeichenfolge ein Palindrom ist:

Anfänger:

string = "madam"
is_palindrome = True

for i in range(len(string) // 2):
    if string[i] != string[-(i + 1)]:
        is_palindrome = False
        break

print(f"Is '{string}' a palindrome?:", is_palindrome)
#Is 'madam' a palindrome?: True

• Vergleicht jedes Zeichen mit dem entsprechenden Zeichen vom Ende der Zeichenfolge und setzt es is_palindromeauf „False“, wenn sie nicht übereinstimmen

def is_palindrome(string):
    return string == string[::-1]

string = "madam"
result = is_palindrome(string)
print(f"Is '{string}' a palindrome?:", result)

• Verwendet die Slicing-Syntax von Python, um die Zeichenfolge umzukehren und sie mit der ursprünglichen Zeichenfolge zu vergleichen

Anfänger:

num = 60
prime_factors = []

for i in range(2, num + 1):
    while num % i == 0:
        prime_factors.append(i)
        num = num // i

print("Prime factors:", prime_factors)
#Prime factors: [2, 2, 3, 5]

• Verwendet eine While-Schleife, um die Zahl wiederholt durch einen Faktor zu dividieren, während sie teilbar ist
• Hängt die Primfaktoren an die Liste an

def prime_factors(num):
    factors = []
    for i in range(2, num + 1):
        while num % i == 0:
            factors.append(i)
            num = num // i
    return factors

num = 60
result = prime_factors(num)
print("Prime factors:", result)

• Verwendet verschachtelte Schleifen, um die Primfaktoren zu identifizieren und sie an die Liste anzuhängen

def prime_factors(num):
    factors = []
    i = 2
    while i * i <= num:
        if num % i:
            i += 1
        else:
            num //= i
            factors.append(i)
    if num > 1:
        factors.append(num)
    return factors

num = 60
result = prime_factors(num)
print("Prime factors:", result)

• Verwendet eine einzelne while-Schleife, um die Zahl wiederholt durch den kleinsten Teiler zu dividieren
• Fügt Primfaktoren an die Liste an und prüft, ob die verbleibende Zahl größer als 1 ist, um den letzten Primfaktor zu berücksichtigen

Anfänger:

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = []

for sublist in nested_list:
    for item in sublist:
        flat_list.append(item)

print("Flat list:", flat_list)
#Flat list: [1, 2, 3, 4, 5, 6, 7, 8, 9]

• Hängt jedes Element an die neue flache Liste an

def flatten_list(nested_list):
    return [item for sublist in nested_list for item in sublist]

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = flatten_list(nested_list)
print("Flat list:", flat_list)

• Verwendet das Verständnis verschachtelter Listen, um die flache Liste zu erstellen

from itertools import chain

def flatten_list(nested_list):
    return list(chain.from_iterable(nested_list))

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = flatten_list(nested_list)
print("Flat list:", flat_list)

• Definiert eine Funktion , die die Funktion zum Reduzieren der verschachtelten Liste flatten_listverwendetchain.from_iterable

Anfänger:

sentence = "apple banana apple kiwi banana apple"
word_count = {}

for word in sentence.split():
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

print("Word count:", word_count)

• Verwendet eine einfache for-Schleife, um die Wörter zu durchlaufen und deren Vorkommen in einem Wörterbuch zu zählen

from collections import Counter

def count_words(sentence):
    return Counter(sentence.split())

sentence = "apple banana apple kiwi banana apple"
word_count = count_words(sentence)
print("Word count:", word_count)

• Definiert eine Funktion count_words, die die Klasse verwendet Counter, um die Häufigkeit von Wörtern in einem Satz zu zählen

from collections import defaultdict

def count_words(sentence):
    word_count = defaultdict(int)
    for word in sentence.split():
        word_count[word] += 1
    return word_count

sentence = "apple banana apple kiwi banana apple"
word_count = count_words(sentence)
print("Word count:", word_count)

• Definiert eine Funktion count_words, die ein Standarddict mit ganzzahligen Werten verwendet, um die Häufigkeit von Wörtern zu zählen
• Verwendet die splitMethode zum Tokenisieren des Satzes und eine for-Schleife zum Erhöhen der Wortanzahl

Anfänger:

def merge_dicts(d1, d2):
    merged_dict = d1.copy()
    merged_dict.update(d2)
    return merged_dict

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

#Merged dictionary: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

• Verwendet die copyMethode zum Erstellen einer Kopie des ersten Wörterbuchs und die updateMethode zum Aktualisieren des Wörterbuchs mit den Schlüssel-Wert-Paaren aus dem zweiten Wörterbuch

def merge_dicts(d1, d2):
    return {**d1, **d2}

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

• Verwendet das Wörterbuch-Entpacken ( **d1, **d2), um die Wörterbücher zusammenzuführen

from collections import ChainMap

def merge_dicts(d1, d2):
    return dict(ChainMap(d1, d2))

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

• Definiert eine Funktion merge_dictszum Zusammenführen zweier Wörterbücher
• Verwendet die ChainMapKlasse, um eine kombinierte Ansicht der beiden Wörterbücher zu erstellen und das Ergebnis in ein Wörterbuch umzuwandeln

Anfänger:

def list_difference(lst1, lst2):
    difference = []
    for item in lst1:
        if item not in lst2:
            difference.append(item)
    return difference

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

#List difference: [1, 2, 3]

• Verwendet eine einfache for-Schleife, um die Elemente in der ersten Liste zu durchlaufen, und prüft, ob nicht jedes Element in der zweiten Liste vorhanden ist
• Hängt die eindeutigen Elemente an die Differenzliste an

def list_difference(lst1, lst2):
    return list(set(lst1) - set(lst2))

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

• Konvertiert die Listen in Mengen und verwendet den Mengendifferenzoperator ( -) , um die eindeutigen Elemente zu finden
• Konvertiert das Ergebnis zurück in eine Liste

def list_difference(lst1, lst2):
    return [item for item in lst1 if item not in set(lst2)]

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

• Verwendet Listenverständnis mit einer Bedingung, um eine Liste eindeutiger Elemente zu erstellen
• Konvertiert die zweite Liste in einen Satz, um die Mitgliedschaftstests zu optimieren

Anfänger:

def create_dict(keys, values):
    result = {}
    for key, value in zip(keys, values):
        result[key] = value
    return result

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

#Dictionary: {'name': 'Alice', 'age': 25, 'gender': 'Female'}

• Verwendet eine for-Schleife mit der zipFunktion, die Schlüssel und Werte gleichzeitig zu durchlaufen
• Konstruiert das Wörterbuch, indem jeder Wert dem entsprechenden Schlüssel zugewiesen wird

def create_dict(keys, values):
    return dict(zip(keys, values))

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

• Verwendet die zipFunktion, um die Schlüssel und Werte zu koppeln, und verwendet dann den dictKonstruktor, um das Wörterbuch zu erstellen

def create_dict(keys, values):
    return {key: value for key, value in zip(keys, values)}

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

• Verwendet das Wörterbuchverständnis mit der zipFunktion zum Erstellen des Wörterbuchs

Anfänger:

def replace_word(sentence, old_word, new_word):
    return sentence.replace(old_word, new_word)

sentence = "I like apples. Apples are tasty."
old_word = "apples"
new_word = "oranges"
print(replace_word(sentence, old_word, new_word))

#I like oranges. Apples are tasty.

import re

def replace_word(sentence, old_word, new_word):
    return re.sub(r'\b' + old_word + r'\b', new_word, sentence, flags=re.IGNORECASE)

sentence = "I like apples. Apples are tasty."
old_word = "apples"
new_word = "oranges"
print(replace_word(sentence, old_word, new_word))

      
                

                    
                    
                
            

Anfänger:

def mean(numbers):
    return sum(numbers) / len(numbers)

def standard_deviation(numbers):
    avg = mean(numbers)
    return (sum((x - avg) ** 2 for x in numbers) / len(numbers)) ** 0.5

numbers = [1, 2, 3, 4, 5]
print(standard_deviation(numbers))

#1.4142135623730951

import numpy as np

numbers = [1, 2, 3, 4, 5]
print(np.std(numbers))

      
                

                    
                    
                
            

Anfänger:

from sklearn.preprocessing import OneHotEncoder

data = [['apple'], ['banana'], ['orange'], ['apple'], ['banana']]
encoder = OneHotEncoder()
one_hot_encoded = encoder.fit_transform(data).toarray()
print(one_hot_encoded)

import pandas as pd

data = pd.DataFrame({'fruit': ['apple', 'banana', 'orange', 'apple', 'banana']})
one_hot_encoded = pd.get_dummies(data, columns=['fruit'])
print(one_hot_encoded)

      
                

                    
                    
                
            

Anfänger:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = []
odd_numbers = []

for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)
    else:
        odd_numbers.append(num)

grouped_numbers = {'even': even_numbers, 'odd': odd_numbers}
print("Grouped numbers:", grouped_numbers)
#Grouped numbers: {'even': [2, 4, 6, 8], 'odd': [1, 3, 5, 7, 9]}

• Fügt gerade Zahlen an die even_numbersListe und ungerade Zahlen an die odd_numbersListe an
• Gruppieren Sie die Zahlen in einem Wörterbuch

def group_by_parity(numbers):
    return {
        'even': [num for num in numbers if num % 2 == 0],
        'odd': [num for num in numbers if num % 2 != 0],
    }

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
grouped_numbers = group_by_parity(numbers)
print("Grouped numbers:", grouped_numbers)

• Verwendet Wörterbuchverständnis und Listenverständnis, um das gruppierte Wörterbuch zu erstellen

from collections import defaultdict

def group_by_parity(numbers):
    grouped_numbers = defaultdict(list)
    for num in numbers:
        key = 'even' if num % 2 == 0 else 'odd'
        grouped_numbers[key].append(num)
    return grouped_numbers

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
grouped_numbers = group_by_parity(numbers)
print("Grouped numbers:", grouped_numbers)

• Definiert eine Funktion group_by_parity, die ein Defaultdict verwendet, um Zahlen nach ihrer Parität zu gruppieren
• Durchläuft die Zahlen und hängt sie an den entsprechenden Schlüssel („gerade“ oder „ungerade“) im gruppierten Wörterbuch an

Anfänger:

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
element_count = {}

for num in numbers:
    if num in element_count:
        element_count[num] += 1
    else:
        element_count[num] = 1

most_common_element = max(element_count, key=element_count.get)
print("Most common element:", most_common_element)

#Most common element: 4

• Verwendet die maxFunktion mit dem keyArgument, um das häufigste Element zu finden

from collections import Counter

def most_common_element(lst):
    return Counter(lst).most_common(1)[0][0]

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
result = most_common_element(numbers)
print("Most common element:", result)

• Definiert eine Funktion „most_common_element“, die die Klasse „Counter“ verwendet, um das Vorkommen von Elementen in der Liste zu zählen

from statistics import mode

def most_common_element(lst):
    return mode(lst)

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
result = most_common_element(numbers)
print("Most common element:", result)

• Definiert eine Funktion most_common_element, die die Funktion verwendet mode, um das häufigste Element in der Liste zu finden
• Die modeFunktion gibt das häufigste Element in der Liste zurück

Anfänger:

def dict_to_tuples(d):
    return [(key, value) for key, value in d.items()]

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

# List of tuples: [('a', 1), ('b', 2), ('c', 3)]

• Verwendet ein Listenverständnis mit der itemsMethode des Wörterbuchs, um die Liste der Tupel zu erstellen

def dict_to_tuples(d):
    return list(d.items())

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

• Verwendet die itemsMethode des Wörterbuchs, um die Schlüssel-Wert-Paare als Tupel abzurufen und wandelt das Ergebnis in eine Liste um

from operator import itemgetter

def dict_to_tuples(d):
    return sorted(d.items(), key=itemgetter(0))

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

• Definiert eine Funktion dict_to_tupleszum Konvertieren eines Wörterbuchs in eine Liste von Tupeln
• Verwendet die itemsMethode des Wörterbuchs, um die Schlüssel-Wert-Paare als Tupel abzurufen und sortiert das Ergebnis basierend auf den Schlüsseln

Anfänger:

def find_max_min(numbers):
    max_value = max(numbers)
    min_value = min(numbers)
    return max_value, min_value

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

# Maximum value: 5
# Minimum value: 1

• Verwendet die integrierten Funktionen maxund min, um die Maximal- und Minimalwerte zu ermitteln

def find_max_min(numbers):
    return max(numbers), min(numbers)

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

• Verwendet die integrierten Funktionen maxund min, um die Maximal- und Minimalwerte zu ermitteln, und gibt sie als Tupel zurück

from functools import reduce

def find_max_min(numbers):
    return reduce(lambda acc, x: (max(acc[0], x), min(acc[1], x)), numbers, (float('-inf'), float('inf')))

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

• Definiert eine Funktion find_max_minzum Ermitteln der Maximal- und Minimalwerte in einer Zahlenliste
• Verwendet die reduceFunktion mit einer Lambda-Funktion, um die Maximal- und Minimalwerte zu berechnen, indem jedes Element mit den akkumulierten Werten verglichen wird
• Initialisiert den Akkumulator mit negativer und positiver Unendlichkeit, um die Randfälle zu verarbeiten

Anfänger:

def calculate_mean(numbers):
    return sum(numbers) / len(numbers)

def calculate_median(numbers):
    numbers.sort()
    n = len(numbers)
    if n % 2 == 0:
        return (numbers[n // 2 - 1] + numbers[n // 2]) / 2
    else:
        return numbers[n // 2]

def calculate_mode(numbers):
    counts = {}
    for num in numbers:
        if num in counts:
            counts[num] += 1
        else:
            counts[num] = 1
    return max(counts, key=counts.get)

numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
mean = calculate_mean(numbers)
median = calculate_median(numbers)
mode = calculate_mode(numbers)
print(f"Mean: {mean}, Median: {median}, Mode: {mode}")

#Mean: 5.333333333333333, Median: 5.0, Mode: 4

• Die calculate_meanFunktion ermittelt den Mittelwert, indem sie die Summe der Zahlen durch die Länge der Liste dividiert.
• Die calculate_medianFunktion sortiert die Liste und findet das/die mittlere(n) Element(e), um den Median zu berechnen.
• Die calculate_modeFunktion verwendet ein Wörterbuch, um das Vorkommen jeder Zahl zu zählen und die Zahl mit der höchsten Anzahl zu finden.

from statistics import mean, median, mode

def calculate_mean_median_mode(numbers):
    return mean(numbers), median(numbers), mode(numbers)

numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
mean, median, mode = calculate_mean_median_mode(numbers)
print(f"Mean: {mean}, Median: {median}, Mode: {mode}")

• Die calculate_mean_median_modeFunktion gibt Mittelwert, Median und Modus als Tupel zurück.

from statistics import mean, median, mode
from typing import List, Tuple

def calculate_mean_median_mode(numbers: List[float]) -> Tuple[float, float, float]:
    return mean(numbers), median(numbers), mode(numbers)

def main():
    numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
    mean_val, median_val, mode_val = calculate_mean_median_mode(numbers)
    print(f"Mean: {mean_val}, Median: {median_val}, Mode: {mode_val}")

if __name__ == "__main__":
    main()

• Die Funktion verwendet das statisticsModul, um den Mittelwert, den Median und den Modus zu berechnen.
• Der Code ist in einer mainFunktion organisiert, die aufgerufen wird, wenn das Skript ausgeführt wird.

Anfänger:

def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    result.extend(list1[i:])
    result.extend(list2[j:])
    return result

list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
merged_list = merge_sorted_lists(list1, list2)
print(merged_list)

• Die Funktion verwendet zwei Zeiger (i und j), um die beiden Eingabelisten zu durchlaufen und Elemente zu vergleichen, um die zusammengeführte Liste zu erstellen.
• Die verbleibenden Elemente aus beiden Listen werden an das Ergebnis angehängt.

from heapq import merge
from typing import List

def merge_sorted_lists(list1: List[int], list2: List[int]) -> List[int]:
    return list(merge(list1, list2))

def main():
    list1 = [1, 3, 5, 7]
    list2 = [2, 4, 6, 8]
    merged_list = merge_sorted_lists(list1, list2)
    print(merged_list)

if __name__ == "__main__":
    main()

• Für die Eingabeparameter und den Rückgabetyp sind Typanmerkungen enthalten.
• Der Code ist in einer mainFunktion organisiert, die aufgerufen wird, wenn das Skript ausgeführt wird.

Anfänger:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

number = 5
result = factorial(number)
print(f"The factorial of {number} is {result}.")
#The factorial of 5 is 120.

• Die Funktion enthält einen Basisfall für den Fall, dass der nWert Null ist und 1 zurückgibt.
• Im rekursiven Fall wird die Fakultät durch Multiplikation nmit der Fakultät von berechnet n - 1.

from functools import lru_cache
from typing import Optional

@lru_cache(maxsize=None)
def factorial(n: int) -> Optional[int]:
    if n < 0:
        print("Error: Factorial is not defined for negative numbers.")
        return None
    if n == 0:
        return 1
    return n * factorial(n - 1)

def main():
    number = 5
    result = factorial(number)
    if result is not None:
        print(f"The factorial of {number} is {result}.")
    else:
        print("Could not calculate factorial.")

if __name__ == "__main__":
    main()

• Der @lru_cacheDekorator wird verwendet, um die Fakultätsfunktion zu speichern und Zwischenergebnisse für eine bessere Leistung zwischenzuspeichern.
• Die Funktion prüft auf negative Eingabewerte und gibt bei ungültigen Eingaben eine Fehlermeldung aus.
• Der Code verwendet die mainFunktion zur Codeorganisation und zur Behandlung möglicher Fälle, in denen die Fakultät nicht berechnet werden kann.

Anfänger:

import pandas as pd

def load_csv(file_path):
    return pd.read_csv(file_path)

file_path = "data.csv"
df = load_csv(file_path)
print(df.head())

• Definiert eine Funktion load_csvzum Laden einer CSV-Datei in einen DataFrame mithilfe der read_csvMethode frompandas
• Druckt die ersten paar Zeilen des DataFrame mit der headMethode

import pandas as pd

def load_csv(file_path, use_cols=None, parse_dates=None):
    return pd.read_csv(file_path, usecols=use_cols, parse_dates=parse_dates)

file_path = "data.csv"
selected_columns = ['column1', 'column3']
date_columns = ['date_column']
df = load_csv(file_path, use_cols=selected_columns, parse_dates=date_columns)
print(df.head())

• Definiert eine Funktion load_csvmit optionalen Parametern use_colsund parse_dateszum Auswählen von Spalten bzw. zum Parsen von Datumsspalten
• Lädt die angegebenen Spalten aus der CSV-Datei und analysiert die Datumsspalten als Datetime-Objekte
• Druckt die ersten Zeilen des DataFrame

def max_product(arr):
    max_product = float('-inf')
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            product = arr[i] * arr[j]
            if product > max_product:
                max_product = product
    return max_product

arr = [1, 3, 5, 2, 6, 4]
max_product_result = max_product(arr)
print("Maximum product of two integers:", max_product_result)
#30

• Die Funktion verwendet verschachtelte Schleifen, um alle möglichen Ganzzahlpaare im Array zu berücksichtigen.
• Für jedes Paar wird das Produkt berechnet und der maximale Produktwert entsprechend aktualisiert.

from typing import List

def max_product(arr: List[int]) -> int:
    arr.sort(reverse=True)
    return arr[0] * arr[1]

def main():
    arr = [1, 3, 5, 2, 6, 4]
    max_product_result = max_product(arr)
    print("Maximum product of two integers:", max_product_result)

if __name__ == "__main__":
    main()

• Die Funktion sortiert das Array in absteigender Reihenfolge und gibt das Produkt der ersten beiden Elemente zurück, die die größten sind.
• Für eine bessere Struktur und Lesbarkeit ist der Code mit einer mainFunktion organisiert.

from typing import List
from heapq import nlargest

def max_product(arr: List[int]) -> int:
    largest_nums = nlargest(2, arr)
    return largest_nums[0] * largest_nums[1]

def main():
    arr = [1, 3, 5, 2, 6, 4]
    max_product_result = max_product(arr)
    print("Maximum product of two integers:", max_product_result)

if __name__ == "__main__":
    main()

• Die Funktion gibt das Produkt der beiden größten ganzen Zahlen zurück.
• Der Code ist in einer mainFunktion organisiert, die aufgerufen wird, wenn das Skript ausgeführt wird.

Anfänger:

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

arr = [1, 2, 4, 5, 6, 7, 9, 10]
target = 7
index = binary_search(arr, target)
print(f"Index of {target}:", index)

• Die Funktion verwendet eine whileSchleife, um den Suchbereich basierend auf dem Wert des mittleren Elements wiederholt einzugrenzen.
• Wird der Zielwert gefunden, gibt die Funktion den Index des mittleren Elements zurück; andernfalls wird -1 zurückgegeben.

from typing import List
from bisect import bisect_left

def binary_search(arr: List[int], target: int) -> int:
    index = bisect_left(arr, target)
    return index if index != len(arr) and arr[index] == target else -1

def main():
    arr = [1, 2, 4, 5, 6, 7, 9, 10]
    target = 7
    index = binary_search(arr, target)
    print(f"Index of {target}:", index)

if __name__ == "__main__":
    main()

• Die Funktion prüft, ob der Zielwert am gefundenen Index vorhanden ist, und gibt den Index zurück, wenn er mit dem Ziel übereinstimmt. andernfalls wird -1 zurückgegeben.
• Der Code ist in einer mainFunktion organisiert, die aufgerufen wird, wenn das Skript ausgeführt wird.

Programmieranfänger konzentrieren sich auf die grundlegende Syntax und grundlegende Konzepte, fortgeschrittene Programmierer führen Optimierungen und modularen Code ein, während erfahrene Programmierer fortgeschrittene Techniken, Fehlerbehandlung, Codeorganisation und allgemeine Robustheit nutzen. Um mehr zu erfahren, schauen Sie sich bitte die Referenzen an.

Verweise:

1. Offizielle Dokumentation von Python.org:
   Link:https://docs.python.org/3/tutorial/index.html
2. Python-Kurs der Codecademy:
   Link:https://www.codecademy.com/learn/learn-python-3
3. Courseras Python für alle:
   Link:https://www.coursera.org/specializations/python
4. Googles Python-Klasse:
   Link:https://developers.google.com/edu/python
5. LeetCode:
   Link:https://leetcode.com
6. HackerRank:
   Link:https://www.hackerrank.com/domains/tutorials/10-days-of-python
7. Codewars:
   Link:https://www.codewars.com
8. Stapelüberlauf:
   Link:https://stackoverflow.com/questions/tagged/python
9. Python Reddit Community (r/Python):
   Link:https://www.reddit.com/r/Python/
10. Python-Discord-Community:
    Link:https://pythondiscord.com

Vielen Dank, dass Sie Teil unserer Community sind! Bevor du gehst:

• Klatschen Sie für die Geschichte und folgen Sie dem Autor
• Weitere Inhalte finden Sie in der Level Up Coding-Publikation
• Kostenloser Programmier-Interviewkurs ⇒ Kurs ansehen
• Folgen Sie uns: Twitter | LinkedIn | Newsletter