如何在不冻结程序的情况下计算变量的变化？ [蟒蛇]

Question

I am working on a very basic dice roll program in Python and am currently adding an ETA system (asking the program to roll the dice 1000000+ times takes a while and some may see it as a crash) and the system that I've thought up is the following:

Since the "dice" is "rolled" by generating a random number and repeated in a for loop, if I take the variable and compare it to the variable after a second, I could do some basic maths to guess the time remaining.

My issue is how I could wait a second between counting without freezing the program entirely (time.sleep).

Any help would be appreciated, thank you!

CODE:

    import random
finished = 0
printresults = 0
dicesides = 0
rolls = 0
amountcompleted = 0
while finished !="n":
    finished = 0
    printresults = 0
    dicesides = 0
    rolls = 0
    amountcompleted = 0
    rollsdone = 0
    countlist = []

    rolls = int(input("How many times should the dice be rolled? ")) #Variable that counts how many times the dice should be rolled

    dicesides = int(input("How many sides does the dice have? ")) #Variable that contains how many sides the dice has

    while printresults !="y" and printresults !="n":
        printresults = input("Print dice roll results as they're created? say y/n ") #If user says y, result will be printed as results are made
        if printresults !="y" and printresults !="n":
            print("Answer invalid")  

    while amountcompleted !="y" and amountcompleted !="n":
        amountcompleted = input("Print the amount of rolls completed as the dice is rolled? (Reccomended when rolling over 1M times) answer y/n ")
        if amountcompleted !="y" and amountcompleted !="n":
            print("Answer invalid")

    for counter in range(0,dicesides): #Creates list of the right length to hold results
        countlist.append(0)

    for counter in range (0,rolls): #Main bit of the script that actually calculates and stores amount of dice rolls
        number = random.randint(1,dicesides) #"Rolls" the dice, using the dicesides variable.
        if printresults == "y":
            print(number) #Prints the results as they are made if enabled
        if amountcompleted == "y":
            (rollsdone) = int(rollsdone + 1)
            print("Completed {0} rolls".format((rollsdone)))
        for counter in range (0,dicesides + 1): #For variable to store the results in a list
            if number == counter:
                countlist[counter-1] = countlist[counter-1] + 1 #Adds 1 to the right bit of the list

    for counter in range(0,dicesides):
        print("Number of {0}s: {1}".format(counter + 1,countlist[counter])) #Prints results
    while finished != "y" and finished != "n":
        finished = input("Reroll? Answer y/n ") #Asks the user if they want to reroll with different settings
        if finished != "y" and finished != "n":
            print("Input invalid")

Answer 1

import time, random

def roll(n):
    timeStarted = time.time()
    recorded = False
    for x in range(1, n + 1, 1):
        random.randint(1, 6)

        now = time.time()

        if (int(now) - int(timeStarted) == 1) and not (recorded):
            recorded = True
            rollsSecond = n - x
            print(rollsSecond, "rolls per second")

roll(10000000)

Checks the time on starting and compares a second later

Answer 2

if you time difference between use something like this,

>>>import time
>>> s = time.time()
>>> for i in range(10):
...   print i
... 
0
1
2
3
4
5
6
7
8
9
>>>end = time.time()-s
>>> print end
15.814720153808594
>>> 

here s is the starting time. will get difference once process was done... it is end

Answer 3

Just to contribute. You can easily create a decorator and use it throughout your app. Here's an example :

class TimeMuncher(object):
  def __init__(self, f):
    self.start = None
    self.stop = None
    self.function = f

  def __call__(self, *args):
    self.start = time.time() * 1000.0
    self.function(*args)
    self.stop = time.time() * 1000.0
    self.tell_time()

  def tell_time(self):
    #or log..
    print("{} : {} ms".format(self.function.__name__, self.stop -
    self.start))

@TimeMuncher
def aFunction(name, no):
  print("my function " + name + str(no) )

aFunction("hello", 2)

So each time a function, or a method, is called you can manage the time it takes to do its job. It's easily customizable thanks to python OO.

EDIT : I think you should refactor your code so you can evaluate time on specific logic of your program instead of the current huge function you're using.

EDIT 2 : You could setup a CURRENT_TIME / WAIT_TIME static variable on TimeMuncher and only log/print your time at given interval by editing __init__() and __call__() .