Elysia Tools
Mobile Navigation
Python
Web Python Datenstrukturen Beispiele
Web Python Datenstrukturen Beispiele einschließlich Array-Operationen, Hashtabellen und verketteten Listen
Beispiele
Einträge in dieser Sammlung
QuellcodepythonEinfach
Array-Operationen
Array-/Listenoperationen ausführen einschließlich CRUD, Sortierung, Suche und Transformationen
Schwierigkeit
4/10
Geschätzte Zeit
30 min
Schlagwörter
python, web, data structures, arrays
Voraussetzungen
Basic Python, Lists
python
# Web Python Array Operations Examples
# Using Python lists for array operations with comprehensive CRUD functionality
# 1. Basic Array/List Operations
from typing import List, Any, Optional, Callable
import bisect
def create_array(elements: List[Any] = None) -> List[Any]:
"""
Create a new array (list)
Args:
elements: Initial elements
Returns:
New list
"""
return elements.copy() if elements else []
def add_element(array: List[Any], element: Any, position: Optional[int] = None) -> List[Any]:
"""
Add element to array
Args:
array: Target array
element: Element to add
position: Position to insert (None = append)
Returns:
Modified array
"""
if position is None:
array.append(element)
else:
array.insert(position, element)
return array
def remove_element(array: List[Any], element: Any) -> bool:
"""
Remove element from array
Args:
array: Target array
element: Element to remove
Returns:
True if removed
"""
try:
array.remove(element)
return True
except ValueError:
return False
def remove_at(array: List[Any], index: int) -> Any:
"""
Remove element at index
Args:
array: Target array
index: Index to remove
Returns:
Removed element
"""
if 0 <= index < len(array):
return array.pop(index)
return None
def get_element(array: List[Any], index: int) -> Any:
"""
Get element at index
Args:
array: Target array
index: Index to get
Returns:
Element at index
"""
return array[index] if 0 <= index < len(array) else None
def update_element(array: List[Any], index: int, new_value: Any) -> bool:
"""
Update element at index
Args:
array: Target array
index: Index to update
new_value: New value
Returns:
True if updated
"""
if 0 <= index < len(array):
array[index] = new_value
return True
return False
def find_index(array: List[Any], element: Any) -> int:
"""
Find index of element
Args:
array: Target array
element: Element to find
Returns:
Index or -1 if not found
"""
try:
return array.index(element)
except ValueError:
return -1
def contains(array: List[Any], element: Any) -> bool:
"""
Check if array contains element
Args:
array: Target array
element: Element to check
Returns:
True if contains
"""
return element in array
def get_size(array: List[Any]) -> int:
"""
Get array size
Args:
array: Target array
Returns:
Array length
"""
return len(array)
def is_empty(array: List[Any]) -> bool:
"""
Check if array is empty
Args:
array: Target array
Returns:
True if empty
"""
return len(array) == 0
def clear_array(array: List[Any]) -> List[Any]:
"""
Clear all elements
Args:
array: Target array
Returns:
Empty array
"""
array.clear()
return array
# 2. Sorting Operations
def bubble_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
"""
Bubble sort algorithm
Args:
array: Array to sort
key: Sort key function
reverse: Sort descending
Returns:
Sorted array
"""
arr = array.copy()
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if key:
a, b = key(arr[j]), key(arr[j + 1])
else:
a, b = arr[j], arr[j + 1]
if reverse:
should_swap = a < b
else:
should_swap = a > b
if should_swap:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
def quick_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
"""
Quick sort algorithm
Args:
array: Array to sort
key: Sort key function
reverse: Sort descending
Returns:
Sorted array
"""
if len(array) <= 1:
return array
pivot = array[len(array) // 2]
if key:
pivot_value = key(pivot)
else:
pivot_value = pivot
left = [x for x in array if (key(x) if key else x) < pivot_value]
middle = [x for x in array if (key(x) if key else x) == pivot_value]
right = [x for x in array if (key(x) if key else x) > pivot_value]
if reverse:
return quick_sort(right, key, reverse) + middle + quick_sort(left, key, reverse)
else:
return quick_sort(left, key, reverse) + middle + quick_sort(right, key, reverse)
def merge_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
"""
Merge sort algorithm
Args:
array: Array to sort
key: Sort key function
reverse: Sort descending
Returns:
Sorted array
"""
if len(array) <= 1:
return array
mid = len(array) // 2
left = merge_sort(array[:mid], key, reverse)
right = merge_sort(array[mid:], key, reverse)
return merge(left, right, key, reverse)
def merge(left: List[Any], right: List[Any], key: Optional[Callable], reverse: bool) -> List[Any]:
"""Merge two sorted arrays"""
result = []
i = j = 0
while i < len(left) and j < len(right):
left_val = key(left[i]) if key else left[i]
right_val = key(right[j]) if key else right[j]
if reverse:
condition = left_val >= right_val
else:
condition = left_val <= right_val
if condition:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
def sort_array(array: List[Any], key: Optional[Callable] = None, reverse: bool = False, algorithm: str = 'builtin') -> List[Any]:
"""
Sort array using specified algorithm
Args:
array: Array to sort
key: Sort key function
reverse: Sort descending
algorithm: 'builtin', 'bubble', 'quick', 'merge'
Returns:
Sorted array
"""
if algorithm == 'bubble':
return bubble_sort(array, key, reverse)
elif algorithm == 'quick':
return quick_sort(array, key, reverse)
elif algorithm == 'merge':
return merge_sort(array, key, reverse)
else:
return sorted(array, key=key, reverse=reverse)
# 3. Searching Operations
def linear_search(array: List[Any], target: Any, key: Optional[Callable] = None) -> int:
"""
Linear search
Args:
array: Array to search
target: Target value
key: Key function for comparison
Returns:
Index or -1 if not found
"""
for i, element in enumerate(array):
value = key(element) if key else element
if value == target:
return i
return -1
def binary_search(array: List[Any], target: Any, key: Optional[Callable] = None) -> int:
"""
Binary search (requires sorted array)
Args:
array: Sorted array to search
target: Target value
key: Key function for comparison
Returns:
Index or -1 if not found
"""
left, right = 0, len(array) - 1
while left <= right:
mid = (left + right) // 2
mid_value = key(array[mid]) if key else array[mid]
if mid_value == target:
return mid
elif mid_value < target:
left = mid + 1
else:
right = mid - 1
return -1
def find_all(array: List[Any], target: Any, key: Optional[Callable] = None) -> List[int]:
"""
Find all occurrences
Args:
array: Array to search
target: Target value
key: Key function for comparison
Returns:
List of indices
"""
indices = []
for i, element in enumerate(array):
value = key(element) if key else element
if value == target:
indices.append(i)
return indices
def find_min(array: List[Any], key: Optional[Callable] = None) -> Any:
"""
Find minimum element
Args:
array: Array to search
key: Key function for comparison
Returns:
Minimum element
"""
if not array:
return None
return min(array, key=key) if key else min(array)
def find_max(array: List[Any], key: Optional[Callable] = None) -> Any:
"""
Find maximum element
Args:
array: Array to search
key: Key function for comparison
Returns:
Maximum element
"""
if not array:
return None
return max(array, key=key) if key else max(array)
# 4. Transformation Operations
def map_array(array: List[Any], func: Callable[[Any], Any]) -> List[Any]:
"""
Apply function to all elements
Args:
array: Source array
func: Transform function
Returns:
New array
"""
return [func(x) for x in array]
def filter_array(array: List[Any], predicate: Callable[[Any], bool]) -> List[Any]:
"""
Filter elements by predicate
Args:
array: Source array
predicate: Filter function
Returns:
Filtered array
"""
return [x for x in array if predicate(x)]
def reduce_array(array: List[Any], func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
"""
Reduce array to single value
Args:
array: Source array
func: Reduce function
initial: Initial value
Returns:
Reduced value
"""
if initial is not None:
result = initial
for x in array:
result = func(result, x)
else:
result = array[0]
for x in array[1:]:
result = func(result, x)
return result
def flatten_array(array: List[Any]) -> List[Any]:
"""
Flatten nested array
Args:
array: Nested array
Returns:
Flattened array
"""
result = []
for element in array:
if isinstance(element, list):
result.extend(flatten_array(element))
else:
result.append(element)
return result
def chunk_array(array: List[Any], size: int) -> List[List[Any]]:
"""
Split array into chunks
Args:
array: Source array
size: Chunk size
Returns:
List of chunks
"""
return [array[i:i + size] for i in range(0, len(array), size)]
# 5. Advanced Operations
def rotate_array(array: List[Any], positions: int) -> List[Any]:
"""
Rotate array
Args:
array: Source array
positions: Positions to rotate (positive = right)
Returns:
Rotated array
"""
if not array:
return array
positions = positions % len(array)
return array[-positions:] + array[:-positions]
def reverse_array(array: List[Any]) -> List[Any]:
"""
Reverse array
Args:
array: Source array
Returns:
Reversed array
"""
return array[::-1]
def shuffle_array(array: List[Any]) -> List[Any]:
"""
Shuffle array randomly
Args:
array: Source array
Returns:
Shuffled array
"""
import random
result = array.copy()
random.shuffle(result)
return result
def unique_array(array: List[Any], key: Optional[Callable] = None) -> List[Any]:
"""
Get unique elements
Args:
array: Source array
key: Key function for uniqueness
Returns:
Unique elements
"""
if key:
seen = set()
result = []
for item in array:
k = key(item)
if k not in seen:
seen.add(k)
result.append(item)
return result
else:
return list(dict.fromkeys(array))
def intersect_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
"""
Find intersection of two arrays
Args:
arr1: First array
arr2: Second array
Returns:
Intersection
"""
return list(set(arr1) & set(arr2))
def union_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
"""
Find union of two arrays
Args:
arr1: First array
arr2: Second array
Returns:
Union
"""
return list(set(arr1) | set(arr2))
def difference_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
"""
Find difference of two arrays
Args:
arr1: First array
arr2: Second array
Returns:
Difference
"""
return list(set(arr1) - set(arr2))
# 6. Statistical Operations
def sum_array(array: List[float]) -> float:
"""Calculate sum of array"""
return sum(array)
def mean_array(array: List[float]) -> float:
"""Calculate mean of array"""
return sum(array) / len(array) if array else 0
def median_array(array: List[float]) -> float:
"""Calculate median of array"""
if not array:
return 0
sorted_arr = sorted(array)
n = len(sorted_arr)
mid = n // 2
if n % 2 == 0:
return (sorted_arr[mid - 1] + sorted_arr[mid]) / 2
else:
return sorted_arr[mid]
def mode_array(array: List[Any]) -> Any:
"""Calculate mode of array"""
from collections import Counter
if not array:
return None
counter = Counter(array)
return counter.most_common(1)[0][0]
def std_deviation(array: List[float]) -> float:
"""Calculate standard deviation"""
import math
if len(array) < 2:
return 0
mean = mean_array(array)
variance = sum((x - mean) ** 2 for x in array) / len(array)
return math.sqrt(variance)
# Usage Examples
def demonstrate_array_operations():
print("=== Web Python Array Operations Examples ===\n")
# 1. Basic operations
print("--- 1. Basic Operations ---")
arr = create_array([3, 1, 4, 1, 5])
print(f"Created: {arr}")
add_element(arr, 9)
print(f"After append: {arr}")
add_element(arr, 2, position=0)
print(f"After insert at 0: {arr}")
print(f"Size: {get_size(arr)}")
# 2. Sorting
print("\n--- 2. Sorting ---")
unsorted = [64, 34, 25, 12, 22, 11, 90]
print(f"Original: {unsorted}")
print(f"Bubble sort: {bubble_sort(unsorted.copy())}")
print(f"Quick sort: {quick_sort(unsorted.copy())}")
print(f"Builtin sort: {sort_array(unsorted.copy())}")
# 3. Searching
print("\n--- 3. Searching ---")
data = [1, 3, 5, 7, 9, 11, 13]
print(f"Array: {data}")
print(f"Linear search for 7: {linear_search(data, 7)}")
print(f"Binary search for 7: {binary_search(data, 7)}")
print(f"Find all 1s: {find_all([1, 2, 1, 3, 1], 1)}")
# 4. Transformations
print("\n--- 4. Transformations ---")
numbers = [1, 2, 3, 4, 5]
print(f"Original: {numbers}")
print(f"Map (x^2): {map_array(numbers, lambda x: x ** 2)}")
print(f"Filter (even): {filter_array(numbers, lambda x: x % 2 == 0)}")
print(f"Reduce (sum): {reduce_array(numbers, lambda a, b: a + b, 0)}")
print(f"Flatten: {flatten_array([1, [2, 3], [4, [5]]])}")
# 5. Advanced operations
print("\n--- 5. Advanced Operations ---")
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"Original: {data}")
print(f"Rotate 3: {rotate_array(data, 3)}")
print(f"Reverse: {reverse_array(data)}")
print(f"Unique: {unique_array([1, 2, 2, 3, 3, 3, 4])}")
print(f"Chunk size 3: {chunk_array(data, 3)}")
# 6. Statistical
print("\n--- 6. Statistical Operations ---")
numbers = [2, 4, 4, 4, 5, 5, 7, 9]
print(f"Data: {numbers}")
print(f"Sum: {sum_array(numbers)}")
print(f"Mean: {mean_array(numbers):.2f}")
print(f"Median: {median_array(numbers)}")
print(f"Mode: {mode_array(numbers)}")
print(f"Std deviation: {std_deviation(numbers):.2f}")
print("\n=== All Array Operations Examples Completed ===")
# Export functions
# export { create_array, add_element, remove_element, remove_at, get_element, update_element }
# export { find_index, contains, get_size, is_empty, clear_array }
# export { bubble_sort, quick_sort, merge_sort, sort_array }
# export { linear_search, binary_search, find_all, find_min, find_max }
# export { map_array, filter_array, reduce_array, flatten_array, chunk_array }
# export { rotate_array, reverse_array, shuffle_array, unique_array }
# export { intersect_arrays, union_arrays, difference_arrays }
# export { sum_array, mean_array, median_array, mode_array, std_deviation }
# export { demonstrate_array_operations }
QuellcodepythonMittel
Hashtabelle
Hashtabellen (Wörterbücher) implementieren und verwenden für Schlüssel-Wert-Speicherung und Suchvorgänge
Schwierigkeit
5/10
Geschätzte Zeit
25 min
Schlagwörter
python, web, data structures, hash table
Voraussetzungen
Intermediate Python, Dictionaries
python
# Web Python Hash Table Examples
# Using Python dictionaries for key-value storage and efficient lookups
# 1. Basic Dictionary Operations
from typing import Any, Dict, List, Optional, Callable
def create_hash_table(elements: Dict[Any, Any] = None) -> Dict[Any, Any]:
"""
Create a new hash table (dictionary)
Args:
elements: Initial key-value pairs
Returns:
New dictionary
"""
return elements.copy() if elements else {}
def put(ht: Dict[Any, Any], key: Any, value: Any) -> None:
"""
Add or update key-value pair
Args:
ht: Hash table
key: Key
value: Value
"""
ht[key] = value
def get(ht: Dict[Any, Any], key: Any, default: Any = None) -> Any:
"""
Get value by key
Args:
ht: Hash table
key: Key to lookup
default: Default value if key not found
Returns:
Value or default
"""
return ht.get(key, default)
def remove(ht: Dict[Any, Any], key: Any) -> bool:
"""
Remove key-value pair
Args:
ht: Hash table
key: Key to remove
Returns:
True if removed
"""
if key in ht:
del ht[key]
return True
return False
def contains_key(ht: Dict[Any, Any], key: Any) -> bool:
"""
Check if key exists
Args:
ht: Hash table
key: Key to check
Returns:
True if key exists
"""
return key in ht
def contains_value(ht: Dict[Any, Any], value: Any) -> bool:
"""
Check if value exists
Args:
ht: Hash table
value: Value to check
Returns:
True if value exists
"""
return value in ht.values()
def get_size(ht: Dict[Any, Any]) -> int:
"""
Get hash table size
Args:
ht: Hash table
Returns:
Number of key-value pairs
"""
return len(ht)
def is_empty(ht: Dict[Any, Any]) -> bool:
"""
Check if hash table is empty
Args:
ht: Hash table
Returns:
True if empty
"""
return len(ht) == 0
def clear_hash_table(ht: Dict[Any, Any]) -> None:
"""
Clear all entries
Args:
ht: Hash table
"""
ht.clear()
def get_keys(ht: Dict[Any, Any]) -> List[Any]:
"""
Get all keys
Args:
ht: Hash table
Returns:
List of keys
"""
return list(ht.keys())
def get_values(ht: Dict[Any, Any]) -> List[Any]:
"""
Get all values
Args:
ht: Hash table
Returns:
List of values
"""
return list(ht.values())
def get_items(ht: Dict[Any, Any]) -> List[tuple]:
"""
Get all key-value pairs
Args:
ht: Hash table
Returns:
List of tuples
"""
return list(ht.items())
# 2. Advanced Operations
def update_hash_table(ht: Dict[Any, Any], other: Dict[Any, Any]) -> None:
"""
Update with another dictionary
Args:
ht: Target hash table
other: Source dictionary
"""
ht.update(other)
def merge_hash_tables(ht1: Dict[Any, Any], ht2: Dict[Any, Any]) -> Dict[Any, Any]:
"""
Merge two hash tables
Args:
ht1: First hash table
ht2: Second hash table
Returns:
Merged hash table
"""
result = ht1.copy()
result.update(ht2)
return result
def set_default(ht: Dict[Any, Any], key: Any, default: Any) -> Any:
"""
Set default value if key doesn't exist
Args:
ht: Hash table
key: Key
default: Default value
Returns:
Value (existing or default)
"""
return ht.setdefault(key, default)
def pop_value(ht: Dict[Any, Any], key: Any, default: Any = None) -> Any:
"""
Remove and return value
Args:
ht: Hash table
key: Key
default: Default if key not found
Returns:
Removed value or default
"""
return ht.pop(key, default)
def pop_item(ht: Dict[Any, Any]) -> tuple:
"""
Remove and return arbitrary item
Args:
ht: Hash table
Returns:
(key, value) tuple
"""
return ht.popitem()
# 3. Dictionary Comprehensions
def create_from_keys(keys: List[Any], value: Any) -> Dict[Any, Any]:
"""
Create dict from keys with same value
Args:
keys: List of keys
value: Value for all keys
Returns:
Dictionary
"""
return {key: value for key in keys}
def create_from_mapping(keys: List[Any], func: Callable[[Any], Any]) -> Dict[Any, Any]:
"""
Create dict by mapping keys through function
Args:
keys: List of keys
func: Function to generate values
Returns:
Dictionary
"""
return {key: func(key) for key in keys}
def filter_hash_table(ht: Dict[Any, Any], predicate: Callable[[tuple], bool]) -> Dict[Any, Any]:
"""
Filter entries by predicate
Args:
ht: Hash table
predicate: Filter function
Returns:
Filtered dictionary
"""
return {k: v for k, v in ht.items() if predicate((k, v))}
def invert_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
"""
Invert key-value pairs
Args:
ht: Hash table
Returns:
Inverted dictionary
"""
return {v: k for k, v in ht.items()}
# 4. Sorting Operations
def sort_by_keys(ht: Dict[Any, Any], reverse: bool = False) -> List[tuple]:
"""
Sort entries by keys
Args:
ht: Hash table
reverse: Sort descending
Returns:
Sorted list of tuples
"""
return sorted(ht.items(), key=lambda x: x[0], reverse=reverse)
def sort_by_values(ht: Dict[Any, Any], reverse: bool = False) -> List[tuple]:
"""
Sort entries by values
Args:
ht: Hash table
reverse: Sort descending
Returns:
Sorted list of tuples
"""
return sorted(ht.items(), key=lambda x: x[1], reverse=reverse)
def get_sorted_keys(ht: Dict[Any, Any], reverse: bool = False) -> List[Any]:
"""Get sorted keys"""
return sorted(ht.keys(), reverse=reverse)
def get_sorted_values(ht: Dict[Any, Any], reverse: bool = False) -> List[Any]:
"""Get sorted values"""
return sorted(ht.values(), reverse=reverse)
# 5. Lookup Operations
def find_keys_by_value(ht: Dict[Any, Any], value: Any) -> List[Any]:
"""
Find all keys with given value
Args:
ht: Hash table
value: Value to search
Returns:
List of keys
"""
return [k for k, v in ht.items() if v == value]
def find_max_value(ht: Dict[Any, Any]) -> tuple:
"""
Find entry with maximum value
Args:
ht: Hash table
Returns:
(key, value) tuple
"""
return max(ht.items(), key=lambda x: x[1])
def find_min_value(ht: Dict[Any, Any]) -> tuple:
"""
Find entry with minimum value
Args:
ht: Hash table
Returns:
(key, value) tuple
"""
return min(ht.items(), key=lambda x: x[1])
# 6. Hash Table Utilities
def copy_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
"""
Create shallow copy
Args:
ht: Hash table
Returns:
Copy
"""
return ht.copy()
def deep_copy_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
"""
Create deep copy
Args:
ht: Hash table
Returns:
Deep copy
"""
import copy
return copy.deepcopy(ht)
def to_string(ht: Dict[Any, Any], indent: int = 0) -> str:
"""
Convert to formatted string
Args:
ht: Hash table
indent: Indentation level
Returns:
Formatted string
"""
import json
return json.dumps(ht, indent=indent, default=str)
def from_tuples(items: List[tuple]) -> Dict[Any, Any]:
"""
Create dict from list of tuples
Args:
items: List of (key, value) tuples
Returns:
Dictionary
"""
return dict(items)
def from_lists(keys: List[Any], values: List[Any]) -> Dict[Any, Any]:
"""
Create dict from two lists
Args:
keys: List of keys
values: List of values
Returns:
Dictionary
"""
return dict(zip(keys, values))
# 7. Specialized Hash Tables
def create_counter(items: List[Any]) -> Dict[Any, int]:
"""
Count occurrences
Args:
items: List of items
Returns:
Dictionary with counts
"""
counter = {}
for item in items:
counter[item] = counter.get(item, 0) + 1
return counter
def create_index(items: List[Any], key_func: Callable[[Any], Any]) -> Dict[Any, List[Any]]:
"""
Create index by key function
Args:
items: List of items
key_func: Function to extract key
Returns:
Dictionary mapping keys to lists of items
"""
index = {}
for item in items:
key = key_func(item)
if key not in index:
index[key] = []
index[key].append(item)
return index
def group_by(items: List[Any], key_func: Callable[[Any], Any]) -> Dict[Any, List[Any]]:
"""
Group items by key function
Args:
items: List of items
key_func: Function to extract key
Returns:
Grouped dictionary
"""
groups = {}
for item in items:
key = key_func(item)
if key not in groups:
groups[key] = []
groups[key].append(item)
return groups
# 8. Nested Dictionary Operations
def get_nested(ht: Dict[Any, Any], *keys, default: Any = None) -> Any:
"""
Get value from nested dictionary
Args:
ht: Hash table
*keys: Keys for nested access
default: Default value
Returns:
Nested value or default
"""
current = ht
for key in keys:
if isinstance(current, dict) and key in current:
current = current[key]
else:
return default
return current
def set_nested(ht: Dict[Any, Any], *keys, value: Any) -> None:
"""
Set value in nested dictionary
Args:
ht: Hash table
*keys: Keys for nested access
value: Value to set
"""
current = ht
for key in keys[:-1]:
if key not in current:
current[key] = {}
current = current[key]
current[keys[-1]] = value
def flatten_nested_dict(ht: Dict[Any, Any], parent_key: str = '', sep: str = '.') -> Dict[Any, Any]:
"""
Flatten nested dictionary
Args:
ht: Hash table
parent_key: Parent key prefix
sep: Separator for keys
Returns:
Flattened dictionary
"""
items = []
for k, v in ht.items():
new_key = f"{parent_key}{sep}{k}" if parent_key else k
if isinstance(v, dict):
items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
else:
items.append((new_key, v))
return dict(items)
# Usage Examples
def demonstrate_hash_table():
print("=== Web Python Hash Table Examples ===\n")
# 1. Basic operations
print("--- 1. Basic Operations ---")
ht = create_hash_table({'name': 'Alice', 'age': 30})
print(f"Created: {ht}")
put(ht, 'city', 'NYC')
print(f"After put: {ht}")
print(f"Get name: {get(ht, 'name')}")
print(f"Contains 'age': {contains_key(ht, 'age')}")
print(f"Keys: {get_keys(ht)}")
print(f"Values: {get_values(ht)}")
print(f"Size: {get_size(ht)}")
# 2. Advanced operations
print("\n--- 2. Advanced Operations ---")
ht1 = {'a': 1, 'b': 2}
ht2 = {'c': 3, 'd': 4}
merged = merge_hash_tables(ht1, ht2)
print(f"Merged: {merged}")
set_default(ht1, 'e', 5)
print(f"Set default: {ht1}")
inverted = invert_hash_table({'a': 1, 'b': 2, 'c': 3})
print(f"Inverted: {inverted}")
# 3. Sorting
print("\n--- 3. Sorting ---")
data = {'apple': 5, 'banana': 2, 'cherry': 8, 'date': 1}
print(f"Original: {data}")
print(f"Sort by keys: {sort_by_keys(data)}")
print(f"Sort by values: {sort_by_values(data)}")
print(f"Max value: {find_max_value(data)}")
print(f"Min value: {find_min_value(data)}")
# 4. Lookup operations
print("\n--- 4. Lookup Operations ---")
scores = {'Alice': 95, 'Bob': 87, 'Charlie': 95, 'David': 92}
print(f"Scores: {scores}")
print(f"Keys with value 95: {find_keys_by_value(scores, 95)}")
# 5. Specialized dictionaries
print("\n--- 5. Specialized Dictionaries ---")
items = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
counter = create_counter(items)
print(f"Counter: {counter}")
data = [
{'name': 'Alice', 'dept': 'IT'},
{'name': 'Bob', 'dept': 'HR'},
{'name': 'Charlie', 'dept': 'IT'}
]
grouped = group_by(data, lambda x: x['dept'])
print(f"Grouped by dept: {grouped}")
# 6. Nested dictionaries
print("\n--- 6. Nested Dictionaries ---")
nested = {
'user': {
'name': 'Alice',
'address': {
'city': 'NYC',
'zip': '10001'
}
}
}
print(f"Nested: {nested}")
print(f"Get nested: {get_nested(nested, 'user', 'address', 'city')}")
set_nested(nested, 'user', 'address', 'zip', value='10002')
print(f"After set: {nested}")
print(f"Flattened: {flatten_nested_dict(nested)}")
print("\n=== All Hash Table Examples Completed ===")
# Export functions
# export { create_hash_table, put, get, remove, contains_key, contains_value }
# export { get_size, is_empty, clear_hash_table, get_keys, get_values, get_items }
# export { update_hash_table, merge_hash_tables, set_default, pop_value, pop_item }
# export { create_from_keys, create_from_mapping, filter_hash_table, invert_hash_table }
# export { sort_by_keys, sort_by_values, get_sorted_keys, get_sorted_values }
# export { find_keys_by_value, find_max_value, find_min_value }
# export { copy_hash_table, deep_copy_hash_table, to_string, from_tuples, from_lists }
# export { create_counter, create_index, group_by }
# export { get_nested, set_nested, flatten_nested_dict }
# export { demonstrate_hash_table }
QuellcodepythonKomplex
Verkettete Liste
Einfach verkettete Listen implementieren und verwenden mit Einfügungs-, Lösch-, Durchlauf- und Umkehrungsoperationen
Schwierigkeit
7/10
Geschätzte Zeit
35 min
Schlagwörter
python, web, data structures, linked list
Voraussetzungen
Advanced Python, Classes, Pointers
python
# Web Python Linked List Examples
# Implementation of singly linked list with comprehensive operations
# 1. Node Class
class Node:
"""Linked list node"""
def __init__(self, data: Any = None):
self.data = data
self.next: Optional['Node'] = None
def __repr__(self):
return f"Node({self.data})"
# 2. Linked List Class
class LinkedList:
"""Singly linked list implementation"""
def __init__(self):
self.head: Optional[Node] = None
self.size = 0
def __repr__(self):
values = []
current = self.head
while current:
values.append(str(current.data))
current = current.next
return " -> ".join(values) if values else "Empty List"
def __len__(self):
return self.size
def __iter__(self):
current = self.head
while current:
yield current.data
current = current.next
# 3. Insertion Operations
def append(self, data: Any) -> None:
"""
Append element to end
Args:
data: Data to append
"""
new_node = Node(data)
if not self.head:
self.head = new_node
else:
current = self.head
while current.next:
current = current.next
current.next = new_node
self.size += 1
def prepend(self, data: Any) -> None:
"""
Add element to beginning
Args:
data: Data to prepend
"""
new_node = Node(data)
new_node.next = self.head
self.head = new_node
self.size += 1
def insert_at(self, index: int, data: Any) -> bool:
"""
Insert element at index
Args:
index: Insertion index
data: Data to insert
Returns:
True if successful
"""
if index < 0 or index > self.size:
return False
if index == 0:
self.prepend(data)
return True
new_node = Node(data)
current = self.head
for _ in range(index - 1):
current = current.next
new_node.next = current.next
current.next = new_node
self.size += 1
return True
def insert_after(self, target_data: Any, new_data: Any) -> bool:
"""
Insert after target element
Args:
target_data: Target element data
new_data: New element data
Returns:
True if successful
"""
current = self.head
while current:
if current.data == target_data:
new_node = Node(new_data)
new_node.next = current.next
current.next = new_node
self.size += 1
return True
current = current.next
return False
def insert_before(self, target_data: Any, new_data: Any) -> bool:
"""
Insert before target element
Args:
target_data: Target element data
new_data: New element data
Returns:
True if successful
"""
if not self.head:
return False
if self.head.data == target_data:
self.prepend(new_data)
return True
current = self.head
while current.next:
if current.next.data == target_data:
new_node = Node(new_data)
new_node.next = current.next
current.next = new_node
self.size += 1
return True
current = current.next
return False
# 4. Deletion Operations
def delete(self, data: Any) -> bool:
"""
Delete first occurrence of data
Args:
data: Data to delete
Returns:
True if deleted
"""
if not self.head:
return False
if self.head.data == data:
self.head = self.head.next
self.size -= 1
return True
current = self.head
while current.next:
if current.next.data == data:
current.next = current.next.next
self.size -= 1
return True
current = current.next
return False
def delete_at(self, index: int) -> bool:
"""
Delete element at index
Args:
index: Index to delete
Returns:
True if deleted
"""
if index < 0 or index >= self.size:
return False
if index == 0:
self.head = self.head.next
self.size -= 1
return True
current = self.head
for _ in range(index - 1):
current = current.next
current.next = current.next.next
self.size -= 1
return True
def delete_head(self) -> bool:
"""
Delete head element
Returns:
True if deleted
"""
if not self.head:
return False
self.head = self.head.next
self.size -= 1
return True
def delete_tail(self) -> bool:
"""
Delete tail element
Returns:
True if deleted
"""
if not self.head:
return False
if not self.head.next:
self.head = None
else:
current = self.head
while current.next.next:
current = current.next
current.next = None
self.size -= 1
return True
# 5. Search Operations
def find(self, data: Any) -> Optional[Node]:
"""
Find node containing data
Args:
data: Data to find
Returns:
Node or None
"""
current = self.head
while current:
if current.data == data:
return current
current = current.next
return None
def contains(self, data: Any) -> bool:
"""
Check if data exists
Args:
data: Data to check
Returns:
True if exists
"""
return self.find(data) is not None
def index_of(self, data: Any) -> int:
"""
Get index of data
Args:
data: Data to find
Returns:
Index or -1
"""
current = self.head
index = 0
while current:
if current.data == data:
return index
current = current.next
index += 1
return -1
def get_at(self, index: int) -> Optional[Any]:
"""
Get data at index
Args:
index: Index
Returns:
Data or None
"""
if index < 0 or index >= self.size:
return None
current = self.head
for _ in range(index):
current = current.next
return current.data
# 6. Traversal Operations
def to_list(self) -> list:
"""
Convert to Python list
Returns:
List of data
"""
result = []
current = self.head
while current:
result.append(current.data)
current = current.next
return result
def traverse(self, func: callable) -> None:
"""
Apply function to each element
Args:
func: Function to apply
"""
current = self.head
while current:
func(current.data)
current = current.next
def print_list(self) -> None:
"""Print linked list"""
print(self)
# 7. Update Operations
def update(self, index: int, new_data: Any) -> bool:
"""
Update data at index
Args:
index: Index
new_data: New data
Returns:
True if updated
"""
if index < 0 or index >= self.size:
return False
current = self.head
for _ in range(index):
current = current.next
current.data = new_data
return True
# 8. Utility Operations
def is_empty(self) -> bool:
"""
Check if list is empty
Returns:
True if empty
"""
return self.head is None
def clear(self) -> None:
"""Clear all elements"""
self.head = None
self.size = 0
def reverse(self) -> None:
"""Reverse the linked list"""
prev = None
current = self.head
while current:
next_node = current.next
current.next = prev
prev = current
current = next_node
self.head = prev
def get_length(self) -> int:
"""
Get length of list
Returns:
Length
"""
return self.size
def copy(self) -> 'LinkedList':
"""
Create shallow copy
Returns:
New linked list
"""
new_list = LinkedList()
current = self.head
while current:
new_list.append(current.data)
current = current.next
return new_list
# 9. Advanced Operations
def count(self, data: Any) -> int:
"""
Count occurrences of data
Args:
data: Data to count
Returns:
Count
"""
count = 0
current = self.head
while current:
if current.data == data:
count += 1
current = current.next
return count
def remove_duplicates(self) -> None:
"""Remove duplicate elements"""
seen = set()
current = self.head
prev = None
while current:
if current.data in seen:
prev.next = current.next
self.size -= 1
else:
seen.add(current.data)
prev = current
current = current.next
def sort(self, reverse: bool = False) -> None:
"""
Sort the linked list
Args:
reverse: Sort descending
"""
# Convert to list, sort, and rebuild
data_list = self.to_list()
data_list.sort(reverse=reverse)
self.clear()
for item in data_list:
self.append(item)
def find_middle(self) -> Optional[Any]:
"""
Find middle element
Returns:
Middle data or None
"""
if not self.head:
return None
slow = self.head
fast = self.head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
return slow.data
def has_cycle(self) -> bool:
"""
Detect cycle using Floyd's algorithm
Returns:
True if cycle exists
"""
if not self.head:
return False
slow = self.head
fast = self.head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False
# 10. Static Creation Methods
@classmethod
def from_list(cls, data_list: list) -> 'LinkedList':
"""
Create linked list from Python list
Args:
data_list: List of data
Returns:
New linked list
"""
linked_list = cls()
for item in data_list:
linked_list.append(item)
return linked_list
# 11. Utility Functions
def merge_sorted_lists(list1: LinkedList, list2: LinkedList) -> LinkedList:
"""
Merge two sorted linked lists
Args:
list1: First sorted list
list2: Second sorted list
Returns:
Merged sorted list
"""
merged = LinkedList()
current1 = list1.head
current2 = list2.head
while current1 and current2:
if current1.data <= current2.data:
merged.append(current1.data)
current1 = current1.next
else:
merged.append(current2.data)
current2 = current2.next
while current1:
merged.append(current1.data)
current1 = current1.next
while current2:
merged.append(current2.data)
current2 = current2.next
return merged
def detect_intersection(list1: LinkedList, list2: LinkedList) -> Optional[Any]:
"""
Detect intersection point of two lists
Args:
list1: First list
list2: Second list
Returns:
Intersection data or None
"""
# Get lengths
len1, len2 = len(list1), len(list2)
# Find starting points
current1 = list1.head
current2 = list2.head
# Advance longer list
for _ in range(abs(len1 - len2)):
if len1 > len2:
current1 = current1.next
else:
current2 = current2.next
# Move both until intersection
while current1 and current2:
if current1 == current2:
return current1.data
current1 = current1.next
current2 = current2.next
return None
# Usage Examples
def demonstrate_linked_list():
print("=== Web Python Linked List Examples ===\n")
# 1. Basic operations
print("--- 1. Basic Operations ---")
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
print(f"After append: {ll}")
ll.prepend(0)
print(f"After prepend: {ll}")
print(f"Length: {ll.get_length()}")
print(f"Is empty: {ll.is_empty()}")
# 2. Insertion
print("\n--- 2. Insertion ---")
ll.insert_at(2, 1.5)
print(f"After insert at 2: {ll}")
ll.insert_after(2, 2.5)
print(f"After insert after 2: {ll}")
# 3. Deletion
print("\n--- 3. Deletion ---")
ll.delete(1.5)
print(f"After delete 1.5: {ll}")
ll.delete_at(0)
print(f"After delete at 0: {ll}")
ll.delete_head()
print(f"After delete head: {ll}")
# 4. Search
print("\n--- 4. Search ---")
ll = LinkedList.from_list([10, 20, 30, 40, 50])
print(f"List: {ll}")
print(f"Contains 30: {ll.contains(30)}")
print(f"Index of 30: {ll.index_of(30)}")
print(f"Get at 2: {ll.get_at(2)}")
print(f"Find middle: {ll.find_middle()}")
# 5. Traversal
print("\n--- 5. Traversal ---")
print("Traverse with print:")
ll.traverse(lambda x: print(f" Item: {x}"))
print(f"To list: {ll.to_list()}")
# 6. Update
print("\n--- 6. Update ---")
ll.update(2, 35)
print(f"After update index 2: {ll}")
# 7. Advanced operations
print("\n--- 7. Advanced Operations ---")
ll = LinkedList.from_list([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
print(f"Original: {ll}")
print(f"Count of 5: {ll.count(5)}")
ll.remove_duplicates()
print(f"After remove duplicates: {ll}")
ll.reverse()
print(f"After reverse: {ll}")
ll.sort()
print(f"After sort: {ll}")
# 8. Merge
print("\n--- 8. Merge Sorted Lists ---")
list1 = LinkedList.from_list([1, 3, 5, 7])
list2 = LinkedList.from_list([2, 4, 6, 8])
print(f"List1: {list1}")
print(f"List2: {list2}")
merged = merge_sorted_lists(list1, list2)
print(f"Merged: {merged}")
# 9. Create from list
print("\n--- 9. Create From List ---")
data = [100, 200, 300, 400]
ll_from_list = LinkedList.from_list(data)
print(f"From list {data}: {ll_from_list}")
# 10. Cycle detection
print("\n--- 10. Cycle Detection ---")
ll = LinkedList.from_list([1, 2, 3, 4])
print(f"List: {ll}")
print(f"Has cycle: {ll.has_cycle()}")
print("\n=== All Linked List Examples Completed ===")
# Export classes and functions
# export { Node, LinkedList }
# export { merge_sorted_lists, detect_intersection, demonstrate_linked_list }
Werkzeuge
Tools, die oft mit diesem Beispiel genutzt werden
Verwandt