Python脚本，每次运行时都会在序列中输入下一个数字。

Question

I am trying to write a script that will have a count that starts a 001, and increasing by one every time that the script is run.

I just help some help started this off, what can I do to set it up so that it knows where it start from every time? Is there is way that I can build it into the script to do this?

My bad ideas about how to do this so far: - Have the number(001) exported to a text file, and have the script change that number at the end of every script (001 +1).

• This number will also be in a spreadsheet, so have the script read to value from the spreadsheet, and add one to that value.

I feel like there has to be an easier way, and I'd prefer a way that was self-contained within the script. Can someone help point me in the right direction?

Thanks for your input.

Answer 1

if you want some kind of state persistance then your options are limited:

1. save the state into a file as you suggest in your question (either a text file or spreadsheet, but spreadsheet is harder to do)
2. change your concept so that instead of "running the script" multiple times, the script is always running, but you give it some kind of signal (keyboard input, GUI with a button etc) to let it know to increment the counter
3. split your script into two halves, a server script and a client. the server would listen for connections from the client, and keep track of the current count, the client would then connect and tell the server to increment the count, if needed it could also send the previous or new count back to the client for some kind of output. this would prevent having many writes to disk, but the count would be lost if the server process is closed.

Answer 2

Here's a quick example of saving state using INI files and JSON files. Both attempt to read a config file, update or initialize a counter, save the new counter back to the config, and then return the counter.

#!/usr/bin/env python3

import configparser
import json
from contextlib import suppress


def get_updated_ini_counter():
    filename = 'config.ini'
    section = 'general'
    option = 'counter'
    starting_count = 100

    config = configparser.ConfigParser()
    config.read(filename)
    counter = 1 + int(config.get(section, option, fallback=starting_count - 1))
    if section not in config:
        config.add_section(section)
    config.set(section, option, str(counter))
    with open('config.ini', 'w') as f:
        config.write(f)
    return counter


def get_updated_json_counter():
    filename = 'config.json'
    option = 'counter'
    starting_count = 100
    config = {}

    with suppress(FileNotFoundError):
        with open(filename) as f:
            config = json.load(f)
    config[option] = 1 + config.get(option, starting_count - 1)
    with open(filename, 'w') as f:
        json.dump(config, f, indent=4)
    return config[option]


if __name__ == '__main__':
    print('ini counter  = {}'.format(get_updated_ini_counter()))
    print('json counter = {}'.format(get_updated_json_counter()))

Answer 3

This seems like a broad question. But say your script is hello.py and it just printing "hello world" , then for a simple case where you're running this script on your own desktop/laptop just include a few lines to keep track of when you last ran the script.

import datetime

def hello():
    print "hello, world"

if __name__ == "__main__":

    now = datetime.datetime.now()
    ## create log
    with open("logs.txt", "a") as log:
        log.write(str(now) + "\n") ## write out to log 

    ## run hello
    hello()

Out:

>python hello.py
hello, world
>python hello.py
hello, world
>python hello.py
hello, world
>python hello.py
hello, world
>python hello.py
hello, world
>cat logs.txt
2017-04-21 10:38:46.629779
2017-04-21 10:38:47.229658
2017-04-21 10:38:47.664318
2017-04-21 10:38:47.957451
2017-04-21 10:38:48.279116

If you need to know the number of times you ran the script on a certain day/hour, you can just export this to Excel or something to show you the distribution of usage over time.

Update, using atexit:

Here is the above example using atexit

The atexit module defines a single function to register cleanup functions. Functions thus registered are automatically executed upon normal interpreter termination.

import atexit
import datetime

def hello():
    print "hello, world"

def saveDateTime():
    now = datetime.datetime.now()
    ## create log
    with open("logs.txt", "a") as log:
        log.write(str(now) + "\n")

def goodbye():
    try:
        _dates = open("logs.txt").read()
        _count = len(_dates)
    except IOError:
        _count = 0
    print 'Goodbye, this script has been run %d times.' % (_count)

if __name__ == "__main__":
    hello() ## run hello
    atexit.register(saveDateTime) ## then log when you used this
    atexit.register(goodbye) ## then log when you used this