如何用Python生成含固定分段ID且末四位递增的14位序列号？

Hey there! Let's break down how to solve your two Python serial number generation questions clearly:

1. Generating a Generic 14-Digit Serial Number #

If you just need a random 14-digit string (with or without leading zeros), here are a couple of straightforward approaches:

Option 1: Random 14-digit number (allows leading zeros) #

Use Python's random module to generate a number between 0 and 99999999999999, then format it as a 14-digit string with leading zeros:

import random

def generate_random_14digit():
    return f"{random.randint(0, 99999999999999):014d}"

# Example usage
print(generate_random_14digit())  # Output might be: 05729183402761

Option 2: Random 14-digit number (no leading zeros) #

If you need the serial to start with a non-zero digit, generate a number between 10000000000000 and 99999999999999:

import random

def generate_nonzero_14digit():
    return str(random.randint(10000000000000, 99999999999999))

# Example usage
print(generate_nonzero_14digit())  # Output might be: 78210345967210

Option 3: Unique serials (combining timestamp + random digits) #

To avoid duplicates, combine a timestamp (in milliseconds) with random digits. This ensures near-unique values even if generating multiple serials quickly:

import time
import random

def generate_unique_14digit():
    # Get last 10 digits of millisecond timestamp
    timestamp_part = str(int(time.time() * 1000))[-10:]
    # Add 4 random digits to reach 14 total
    random_part = str(random.randint(1000, 9999))
    return timestamp_part + random_part

# Example usage
print(generate_unique_14digit())  # Output might be: 16987234561234

2. Generating a 14-Digit Serial with Your Specified Format #

For the structured serial (Local Govt. ID (3) + Zonal ID (2) + Area ID (2) + CDA No. (3) + incrementing 4-digit counter), we can create a reusable class to manage the counter state. This ensures the 4-digit suffix increments correctly each time.

Step 1: The Generator Class #

This class validates input formats, tracks the counter, and generates serials:

class CDASerialGenerator:
    def __init__(self, local_govt_id, zonal_id, area_id, cda_no, start_counter=1):
        # Validate input lengths and digit-only format
        if not (len(local_govt_id) == 3 and local_govt_id.isdigit()):
            raise ValueError("Local Govt. ID must be a 3-digit numeric string")
        if not (len(zonal_id) == 2 and zonal_id.isdigit()):
            raise ValueError("Zonal ID must be a 2-digit numeric string")
        if not (len(area_id) == 2 and area_id.isdigit()):
            raise ValueError("Area ID must be a 2-digit numeric string")
        if not (len(cda_no) == 3 and cda_no.isdigit()):
            raise ValueError("CDA No. must be a 3-digit numeric string")
        if not (1 <= start_counter <= 9999):
            raise ValueError("Start counter must be between 1 and 9999")
        
        self.local_govt_id = local_govt_id
        self.zonal_id = zonal_id
        self.area_id = area_id
        self.cda_no = cda_no
        self.counter = start_counter

    def generate_next(self):
        if self.counter > 9999:
            raise ValueError("Counter limit reached (max 9999)")
        # Format counter to 4 digits with leading zeros
        counter_suffix = f"{self.counter:04d}"
        # Combine all parts into the final serial
        serial = f"{self.local_govt_id}{self.zonal_id}{self.area_id}{self.cda_no}{counter_suffix}"
        # Increment counter for next generation
        self.counter += 1
        return serial

Step 2: Usage Example #

Initialize the generator with your example values and generate serials:

# Create generator with your sample parameters
generator = CDASerialGenerator(
    local_govt_id="121",
    zonal_id="01",
    area_id="01",
    cda_no="001"
)

# Generate first 5 serials
for _ in range(5):
    print(generator.generate_next())

Output:

12101010010001
12101010010002
12101010010003
12101010010004
12101010010005

Step 3: Persist the Counter (Optional) #

If you need the counter to persist across program restarts, modify the class to save/load the counter from a file:

import os

class CDASerialGenerator:
    def __init__(self, local_govt_id, zonal_id, area_id, cda_no, counter_file="serial_counter.txt"):
        # ... existing validation code ...
        
        self.counter_file = counter_file
        # Load counter from file if it exists, else start at 1
        if os.path.exists(counter_file):
            with open(counter_file, 'r') as f:
                saved_counter = int(f.read().strip())
                self.counter = saved_counter if 1 <= saved_counter <= 9999 else 1
        else:
            self.counter = 1

    def generate_next(self):
        if self.counter > 9999:
            raise ValueError("Counter limit reached (max 9999)")
        counter_suffix = f"{self.counter:04d}"
        serial = f"{self.local_govt_id}{self.zonal_id}{self.area_id}{self.cda_no}{counter_suffix}"
        self.counter += 1
        # Save updated counter to file
        with open(self.counter_file, 'w') as f:
            f.write(str(self.counter))
        return serial

内容的提问来源于stack exchange，提问作者MyCDAR