🎯 Exemplos recomendados
Balanced sample collections from various categories for you to explore
Exemplos de Estruturas de Dados Web Python
Exemplos de estruturas de dados Web Python incluindo operações de array, tabelas hash e listas encadeadas
💻 Operações de Array python
🟢 simple
⭐⭐
Realizar operações de array/lista incluindo CRUD, ordenação, busca e transformações
⏱️ 30 min
🏷️ python, web, data structures, arrays
Prerequisites:
Basic Python, Lists
# 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 }
💻 Tabela Hash python
🟡 intermediate
⭐⭐⭐
Implementar e usar tabelas hash (dicionários) para armazenamento e busca de chave-valor
⏱️ 25 min
🏷️ python, web, data structures, hash table
Prerequisites:
Intermediate Python, Dictionaries
# 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 }
💻 Lista Encadeada python
🔴 complex
⭐⭐⭐⭐
Implementar e usar listas encadeadas simples com operações de inserção, exclusão, travessia e reversão
⏱️ 35 min
🏷️ python, web, data structures, linked list
Prerequisites:
Advanced Python, Classes, Pointers
# 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 }