Implémentation du code
Solution complète de remplissage de chaînes binaires
Fonctions de remplissage principales
def pad_binary_left(binary_str: str, length: int = 8) -> str:
"""
Left pad binary string with zeros
Args:
binary_str: Input binary string
length: Desired total length
Returns:
Padded binary string
"""
return binary_str.zfill(length)
def pad_binary_right(binary_str: str, length: int = 8) -> str:
"""
Right pad binary string with zeros
Args:
binary_str: Input binary string
length: Desired total length
Returns:
Padded binary string
"""
return binary_str.ljust(length, '0')
Techniques avancées de remplissage
Classe de remplissage flexible
class BinaryPadder:
@staticmethod
def pad(binary_str: str, length: int = 8,
direction: str = 'left') -> str:
"""
Flexible binary string padding
Args:
binary_str: Input binary string
length: Desired total length
direction: Padding direction
Returns:
Padded binary string
"""
if direction == 'left':
return binary_str.zfill(length)
elif direction == 'right':
return binary_str.ljust(length, '0')
else:
raise ValueError("Invalid padding direction")
Workflow de la stratégie de remplissage
graph TD
A[Input Binary String] --> B{Padding Required?}
B -->|Yes| C[Determine Padding Strategy]
C --> D[Select Padding Direction]
D --> E[Apply Padding]
E --> F[Return Padded String]
B -->|No| G[Return Original String]
Gestion des erreurs et validation
def validate_binary_string(binary_str: str) -> bool:
"""
Validate binary string composition
Args:
binary_str: Input string to validate
Returns:
Boolean indicating valid binary string
"""
return all(char in '01' for char in binary_str)
def safe_pad_binary(binary_str: str, length: int = 8) -> str:
"""
Safe binary string padding with validation
Args:
binary_str: Input binary string
length: Desired total length
Returns:
Padded binary string or raises exception
"""
if not validate_binary_string(binary_str):
raise ValueError("Invalid binary string")
return pad_binary_left(binary_str, length)
Méthode |
Complexité temporelle |
Surcoût mémoire |
zfill() |
O(n) |
Faible |
ljust() |
O(n) |
Faible |
Classe personnalisée |
O(n) |
Modéré |
Exemple d'implémentation dans le monde réel
def process_network_packet(packet_data: str) -> str:
"""
Simulate network packet processing with padding
Args:
packet_data: Raw binary packet data
Returns:
Standardized packet with consistent length
"""
try:
padded_packet = BinaryPadder.pad(
packet_data,
length=32,
direction='left'
)
return padded_packet
except ValueError as e:
print(f"Packet processing error: {e}")
return None
## Example usage in LabEx environment
sample_packet = '10101'
processed_packet = process_network_packet(sample_packet)
print(processed_packet) ## Output: 000000000000000000000010101
Bonnes pratiques
- Toujours valider l'entrée avant le remplissage
- Choisir une stratégie de remplissage appropriée
- Prendre en compte les implications sur les performances
- Utiliser les indications de type et les docstrings
- Gérer les exceptions