Python Gzip 压缩：掌握流压缩和解压缩，适用于全球应用程序

            import gzip
import os

data_to_compress = b"This is a sample string that will be compressed using Python's gzip module. It's important to use bytes for compression."

file_name = "compressed_data.gz"

# Open the gzip file in write binary mode
with gzip.GzipFile(file_name, 'wb') as gz_file:
    gz_file.write(data_to_compress)

print(f"Data successfully compressed to {file_name}")

# Verify file size (optional)
print(f"Original data size: {len(data_to_compress)} bytes")
print(f"Compressed file size: {os.path.getsize(file_name)} bytes")

            

              
                Copy
              
            
          

            import gzip

input_file_path = "large_log.txt"
output_file_path = "large_log.txt.gz"

# Assume large_log.txt exists and contains a lot of text
# For demonstration, let's create a dummy large file:
with open(input_file_path, "w") as f:
    for i in range(100000):
        f.write(f"This is line number {i+1}. Some repetitive text for compression. \n")

print(f"Created dummy input file: {input_file_path}")

try:
    # Open the input file in read text mode
    with open(input_file_path, 'rb') as f_in:
        # Open the output gzip file in write binary mode
        with gzip.GzipFile(output_file_path, 'wb') as f_out:
            # Read data in chunks and write to the gzip file
            while True:
                chunk = f_in.read(4096) # Read in 4KB chunks
                if not chunk:
                    break
                f_out.write(chunk)

    print(f"Successfully compressed {input_file_path} to {output_file_path}")

except FileNotFoundError:
    print(f"Error: Input file {input_file_path} not found.")
except Exception as e:
    print(f"An error occurred: {e}")

            

              
                Copy
              
            
          

            import gzip
import io

def compress_and_send(data_stream, socket):
    # Create an in-memory binary stream (like a file)
    compressed_stream = io.BytesIO()
    
    # Wrap the in-memory stream with gzip.GzipFile
    with gzip.GzipFile(fileobj=compressed_stream, mode='wb') as gz_writer:
        # Write data from the input stream to the gzip writer
        while True:
            chunk = data_stream.read(4096) # Read in chunks
            if not chunk:
                break
            gz_writer.write(chunk)

    # Get the compressed bytes from the in-memory stream
    compressed_data = compressed_stream.getvalue()
    
    # In a real scenario, you would send compressed_data over the socket
    print(f"Sending {len(compressed_data)} bytes of compressed data over socket...")
    # socket.sendall(compressed_data) # Example: send over actual socket

# --- Mock setup for demonstration ---
# Simulate data coming from a source (e.g., a file or database query)
original_data_source = io.BytesIO(b"This is some data to be sent over the network. " * 10000)

# Mock socket object
class MockSocket:
    def sendall(self, data):
        print(f"Mock socket received {len(data)} bytes.")

mock_socket = MockSocket()

print("Starting compression and mock send...")
compress_and_send(original_data_source, mock_socket)
print("Mock send complete.")

            

              
                Copy
              
            
          

            import gzip
import os

# Assuming 'compressed_data.gz' was created in the previous example
file_name = "compressed_data.gz"

if os.path.exists(file_name):
    try:
        # Open the gzip file in read binary mode
        with gzip.GzipFile(file_name, 'rb') as gz_file:
            decompressed_data = gz_file.read()

        print(f"Data successfully decompressed from {file_name}")
        print(f"Decompressed data: {decompressed_data.decode('utf-8')}") # Decode to string for display

    except FileNotFoundError:
        print(f"Error: File {file_name} not found.")
    except gzip.BadGzipFile:
        print(f"Error: File {file_name} is not a valid gzip file.")
    except Exception as e:
        print(f"An error occurred during decompression: {e}")
else:
    print(f"Error: File {file_name} does not exist. Please run the compression example first.")

            

              
                Copy
              
            
          

            import gzip
import io
import os

# Create a dummy compressed file for demonstration
original_content = b"Decompression test. This content will be compressed and then decompressed. " * 5000
compressed_file_for_decomp = "temp_compressed_for_decomp.gz"

with gzip.GzipFile(compressed_file_for_decomp, 'wb') as f_out:
    f_out.write(original_content)

print(f"Created dummy compressed file: {compressed_file_for_decomp}")

output_file_path = "decompressed_output.txt"

try:
    # Open the input gzip file in read binary mode
    with gzip.GzipFile(compressed_file_for_decomp, 'rb') as f_in:
        # Open the output file in write binary mode
        with open(output_file_path, 'wb') as f_out:
            # Read compressed data in chunks and write decompressed data
            while True:
                chunk = f_in.read(4096) # Reads decompressed data in chunks
                if not chunk:
                    break
                f_out.write(chunk)

    print(f"Successfully decompressed {compressed_file_for_decomp} to {output_file_path}")

    # Optional: Verify content integrity (for demonstration)
    with open(output_file_path, 'rb') as f_verify:
        read_content = f_verify.read()
        if read_content == original_content:
            print("Content verification successful: Decompressed data matches original.")
        else:
            print("Content verification failed: Decompressed data does NOT match original.")

except FileNotFoundError:
    print(f"Error: Input file {compressed_file_for_decomp} not found.")
except gzip.BadGzipFile:
    print(f"Error: Input file {compressed_file_for_decomp} is not a valid gzip file.")
except Exception as e:
    print(f"An error occurred during decompression: {e}")
finally:
    # Clean up dummy files
    if os.path.exists(compressed_file_for_decomp):
        os.remove(compressed_file_for_decomp)
    if os.path.exists(output_file_path):
        # os.remove(output_file_path) # Uncomment to remove the output file as well
        pass

            

              
                Copy
              
            
          

            import gzip
import io

def decompress_and_process(socket_stream):
    # Create an in-memory binary stream to hold compressed data
    compressed_buffer = io.BytesIO()
    
    # Read data from the socket in chunks and append to the buffer
    # In a real app, this loop would continue until connection closes or EOF
    print("Receiving compressed data...")
    bytes_received = 0
    while True:
        try:
            # Simulate receiving data from socket. Replace with actual socket.recv()
            # For demo, let's generate some compressed data to simulate receipt
            if bytes_received == 0: # First chunk
                # Simulate sending a small compressed message
                original_msg = b"Hello from the compressed stream! " * 50
                buffer_for_compression = io.BytesIO()
                with gzip.GzipFile(fileobj=buffer_for_compression, mode='wb') as gz_writer:
                    gz_writer.write(original_msg)
                chunk_to_receive = buffer_for_compression.getvalue()
            else:
                chunk_to_receive = b""
            
            if not chunk_to_receive:
                print("No more data from socket.")
                break

            compressed_buffer.write(chunk_to_receive)
            bytes_received += len(chunk_to_receive)
            print(f"Received {len(chunk_to_receive)} bytes. Total received: {bytes_received}")
            
            # In a real app, you might process partially if you have delimiters
            # or know the expected size, but for simplicity here, we'll process after receiving all.

        except Exception as e:
            print(f"Error receiving data: {e}")
            break

    print("Finished receiving. Starting decompression...")
    compressed_buffer.seek(0) # Rewind the buffer to read from the beginning

    try:
        # Wrap the buffer with gzip.GzipFile for decompression
        with gzip.GzipFile(fileobj=compressed_buffer, mode='rb') as gz_reader:
            # Read decompressed data
            decompressed_data = gz_reader.read()
            print("Decompression successful.")
            print(f"Decompressed data: {decompressed_data.decode('utf-8')}")
            # Process the decompressed_data here...
    except gzip.BadGzipFile:
        print("Error: Received data is not a valid gzip file.")
    except Exception as e:
        print(f"An error occurred during decompression: {e}")

# --- Mock setup for demonstration ---
# In a real scenario, 'socket_stream' would be a connected socket object
# For this demo, we'll pass our BytesIO buffer which simulates received data

# Simulate a socket stream that has received some compressed data
# (This part is tricky to mock perfectly without a full socket simulation, 
# so the function itself simulates receiving and then processes)
decompress_and_process(None) # Pass None as the actual socket object is mocked internally for demo

            

              
                Copy
              
            
          

            import gzip

output_filename = "simple_compressed.txt.gz"
content_to_write = "This is a simple text file being compressed using gzip.open().\n"

try:
    # Open in text write mode ('wt') for automatic encoding/decoding
    with gzip.open(output_filename, 'wt', encoding='utf-8') as f:
        f.write(content_to_write)
        f.write("Another line of text.")
    
    print(f"Successfully wrote compressed data to {output_filename}")

except Exception as e:
    print(f"An error occurred: {e}")

            

              
                Copy
              
            
          

            import gzip
import os

input_filename = "simple_compressed.txt.gz"

if os.path.exists(input_filename):
    try:
        # Open in text read mode ('rt') for automatic decoding
        with gzip.open(input_filename, 'rt', encoding='utf-8') as f:
            read_content = f.read()
            print(f"Successfully read decompressed data from {input_filename}")
            print(f"Content: {read_content}")

    except FileNotFoundError:
        print(f"Error: File {input_filename} not found.")
    except gzip.BadGzipFile:
        print(f"Error: File {input_filename} is not a valid gzip file.")
    except Exception as e:
        print(f"An error occurred: {e}")
else:
    print(f"Error: File {input_filename} does not exist. Please run the writing example first.")
finally:
    # Clean up the created file
    if os.path.exists(input_filename):
        os.remove(input_filename)

            

              
                Copy
              
            
          

            import gzip

original_bytes = b"This is a short string that will be compressed and decompressed in memory."

# Compress
compressed_bytes = gzip.compress(original_bytes)
print(f"Original size: {len(original_bytes)} bytes")
print(f"Compressed size: {len(compressed_bytes)} bytes")

# Decompress
decompressed_bytes = gzip.decompress(compressed_bytes)
print(f"Decompressed size: {len(decompressed_bytes)} bytes")

# Verify
print(f"Original equals decompressed: {original_bytes == decompressed_bytes}")
print(f"Decompressed content: {decompressed_bytes.decode('utf-8')}")

            

              
                Copy