The.Leep() team with if/Else statements

Asked

Viewed 3,720 times

7

Hi. I’m at an impasse. My goal is that if the user presses enter or waits 2 seconds it starts "Powerbit", but in an if/Else statement and I don’t know how to do it. Example:

#(...)
elif machine == "" or #tempo:
     if temp >=20:
         print "A iniciar o PowerBIT 1.0..."
         starting_so = time.sleep(float(temp))
#(...) 

Complete code:

    import time

    def text_y():
        with open('Chave de inicialização do SO(não mexer).txt', 'r') as f:
            text = f.readlines()
            return text
        f.close()
    if __name__ == "__main__":
        text_z = text_y()

    def ler_reboot_arquivo():
        try:
            with open('reiniciar.txt', 'r') as f:
                leitura = f.readlines()
                return leitura
            f.close()
        except:
            pass

    if __name__ == "__main__":
        reboot = ler_reboot_arquivo()
#====================<<<código de carregamento de dados>>>============================#
    def ler():                                                                        #
        try:                                                                          #   
            with open('maquina virtual 1ªversão-texto inicial.txt', 'r') as f:        #
                linhas = f.readlines()                                                #
                return linhas                                                         #
            f.close()                                                                 #
        except:                                                                       #
            pass                                                                      #
    try:                                                                              #      
        if __name__ == "__main__":                                                    #
            dados = ler()                                                             #
            dados = "".join(str(s.replace('[', '').replace(']', '')) for s in dados)  #
    except TypeError:                                                                 # 
        pass                                                                          #
#===========<<<<<código de carregamento de dados>>>>>=================================# 
                                                                                  #===#
    def ler_tempo_boot():                                                         #
        with open('Tempo de boot.txt', 'r') as f:                                 #
            linhas = f.readlines()                                                #
            return linhas                                                         #
        f.close()                                                                 #
        f.closed                                                                  #
    if __name__ == "__main__":                                                    #
        temp = ler_tempo_boot()                                                   #
        temp = "".join(str(s.replace('[', '').replace(']', '')) for s in temp)    #=====#
#==============<<<<<código de carregamento de dados>>>>>================================#
    def guardar_password_vm():                                                          #
        try:                                                                            #
            with open('Password VM.txt', 'r') as f:                                     #
                linhas = f.readlines()                                                  #
                return linhas                                                           # 
            f.close()                                                                   #
        except:                                                                         #
            pass                                                                        #
    try:                                                                                #
        if __name__ == "__main__":                                                      #
            writing = guardar_password_vm()                                             #     
            writing = "".join(str(s.replace('[', '').replace(']', '')) for s in writing)#
    except TypeError:                                                                   #
        pass                                                                            #
                                                                                        #
#================<<<código de salvação de dados>>>======================================#
    def guardarTempoBoot(times):                                            #===========#
        with open('Tempo de boot.txt', 'r+') as f:                          #
            f.write(str(times))                                             #
            f.seek(0)                                                       #
        f.close()                                                           #
#================<<<código de salvação de dados>>>==========================#
    def reboot_arquivo():
        turn_off = open('reiniciar.txt', 'w')
        turn_off.write(msm)
        turn_off.close()

    def reiniciar_vm():
        try:
            msm = raw_input("Tem a certeza que pretende reiniciar o SO?")
            if msm == "sim" or msm == "si" or msm == "s":
                print "A guardar dados e a encerrar o SO..."      
                import time
                turn_off_so = time.sleep(10)
                while turn_off_so:
                    reboot_arquivo()
                    for f in user_z:
                        f.close()
                        f.closed
                    for f in entrada_z:
                        f.close()
                        f.closed
                    for f in programas_z:
                        f.close()
                        f.closed

            else:
                palavra_passe_os()
        except:
            encerrar = raw_input("Há programas em execução. Tem a certeza que pretende continuar?")
            if encerrar == "sim" or encerrar == "si" or encerrar == "s":
                print " A encerrar o SO..."
                import time
                sem_guardar = time.sleep(10)
                while sem_guardar:
                    for f in user_z:
                        f.close()
                    for f in entrada_z:
                        f.close() 
                    for f in programas_z:
                        f.close()
            else:
                palavra_passe_os()

    def criar_passe_vm():
        passe = raw_input("Escreve uma password nova:")
        save = raw_input("Guardar alterações?")
        if save == "sim" or save == "si" or save == "s".lower():
            nova_passe = open('Password VM.txt', 'w')
            nova_passe.write(passe)
            nova_passe.close()
        else:
            bios()

    def palavra_passe_vm():
        try:
            if(len(writing) > 0):
                passwordvm = raw_input("Palavra-passe:")
                if passwordvm == (str(writing)) :
                    print "Palavra-passe correta."
                else:
                    print "Palavra-passe incorreta."
                    palavra_passe_vm()
        except TypeError:
            pass
    palavra_passe_vm()

#só fechar no encerramento do SO:
    def user_y():
        with open('Utilizadores.txt', 'r') as f:
            user = f.readlines()
            return user

    if __name__ == "__main__":
        user_z = user_y()
        user_z = "".join(str(s.replace('[', '').replace(']', '')) for s in user_z)


    def entrada_y():
        with open('Password SO.txt', 'r') as f:
            entrada = f.readlines()
            return entrada

    if __name__ == "__main__":
        entrada_z = entrada_y()
        entrada_z = "".join(str(s.replace('[', '').replace(']', '')) for s in entrada_z)

    def programas_y():
        with open('Programas VM.txt', 'r') as f:
            programas = f.readlines()
            return programas

    if __name__ == "__main__":
        programas_z = programas_y()
        programas_z = "".join(str(s.replace('[', '').replace(']', '')) for s in programas_z)
#------------------------------------------------------------------------------
    def passe_so():
        if (len(entrada_z) > 0):
            passe_so = raw_input("Palavra-passe:")
            if passe_so == (str(entrada_z)):
                pass
            else:
                print "Palavra-passe incorreta. Tente de novo"
                passe_so()

    def palavra_passe_os():
        using = raw_input("")
        if using == "Utilizador" or using == "util" or using == "u" or using == "user":
            passe_so()
        elif using == "quit" or using == "q" or using == "exit" or using == "e":
            try: 
                msm = raw_input("Tem a certeza que pretende encerrar o SO?")
                if msm == "sim" or msm == "si" or msm == "s":
                    print "A guardar dados e a encerrar o SO..."      
                    import time
                    turn_off_so = time.sleep(10)
                    while turn_off_so:
                        for f in user_z:
                            f.close()
                            f.closed
                        for f in entrada_z:
                            f.close()
                            f.closed
                        for f in programas_z:
                            f.close()
                            f.closed
                    quit()
            except:
                encerrar = raw_input("Há programas em execução. Tem a certeza que pretende continuar?")
                if encerrar == "sim" or encerrar == "si" or encerrar == "s":
                    print " A encerrar o SO..."
                    import time
                    sem_guardar = time.sleep(10)
                    while sem_guardar:
                        for f in user_z:
                            f.close()
                        for f in entrada_z:
                            f.close() 
                        for f in programas_z:
                            f.close()
                    arranque()
                else:
                    palavra_passe_os()
        elif using == "r" or using == "reiniciar" or using == "restart":
            reiniciar_vm()
        else:
            palavra_passe_os()

#função que inicia a máquina virtual (função que coopera com a função bios()-> se esta tiver sido indevidamente alterada pelo usuário, esta impede o arranque do SO
    def arranque():
        import sys, time, msvcrt
        timeout = 2
        startTime = time.time()
        inp = None
        if (len(dados) == 0):
            print "\nBem vindo à máquina virtual. Prima ENTER para iniciar o SO ou B para aceder ao menu da BIOS setup utility."
        else:
            print dados
        while True:
            if msvcrt.kbhit():
                inp = msvcrt.getch()
                break
            elif time.time() - startTime > timeout:
                break
        machine = raw_input("")
        if machine == "B".upper():
            print "A iniciar o BIOS..."
            import time
            time.sleep(7)
             #bios===========================================================================================================
            def bios():
                print "------------------ \n"
                print "BIOS setup utility \n"
                print "------------------"
                opcao =raw_input("Está no menu da BIOS. Escolha o que pretende aceder: Informações do sistema(a), Data(b), Avançadas(c), Configurações do SO(d) (escreva quit para voltar ao menu de arranque.) \n")
                if opcao == "Informações do sistema" or opcao == "a".lower():
                    print "--------------"
                    print "Maquina virtual"
                    print "--------------"
                    print "Versão: 1.0v 32bit \n Data da criação: 07/06/14 \n Compatível com Windows XP, Windows Vista, Windows 7, Windows 8, Unix, Linux, Ubuntu e Mac OS"
                    print "Todos os direitos reservados © 2014"
                    rebobinar = raw_input("")
                    if rebobinar == "back" or rebobinar == "b" or rebobinar == "":
                        bios()
                    else:
                        bios()
                elif opcao == "Data" or opcao == "b".lower():
                    print "--------------"
                    print "Data"
                    print "--------------"
                    from datetime import datetime
                    now = datetime.now()
                    print "Data atual:"
                    print '%s/%s/%s' % (now.year, now.month, now.day)
                    print '%s:%s:%s' % (now.hour, now.minute, now.second)
                    print "Sistema Operativo(simulado): PowerBIT 1.0® \nInterface: Literal (e GUI nas próximas atualizações) \nLinguagem de programação predefinida: Python"
                    try:
                        import win32api
                        path = "C:/"
                        info = win32api.GetVolumeInformation(path)
                        print( "Número da série do disco rígido: = %d" % info[1] )
                    except ImportError:
                        print "Número da série do disco rígido desconhecido"
                    rebobinar = raw_input("")
                    if rebobinar == "back" or rebobinar == "b" or rebobinar == "":
                        bios()
                    else:
                        bios()
                elif opcao == "Avançadas" or opcao == "c".lower():
                    print "--------------"
                    print "Avançadas"
                    print "--------------"
                    configurar = raw_input("Para configurar as defenições da máquina virtual, escreva a password bitwise para aceder(0b10b100b110b100): \n")
                    if configurar == "0b10b100b110b100":
                        print "As opções disponíveis são: \nAlterar a forma de inicialização(a), \nDesinstalar SO(b), \nCriar permissões especiais para a VM(c), \nVer código fonte da VM(d) \nInformações de Hardware(e) "
                        avanced = raw_input("")
                        if avanced == "Alterar a forma de inicialização" or avanced == "a".lower():
                            alterar = raw_input("O que deseja alterar: \nApresentação inicial da VM(a), \nApresentar código de arranque(b)(aviso: qualquer alteração incorreta destes pode instabilizar a VM)?")
                            if alterar == "Apresentação inicial da VM" or alterar == "a".lower():
                                imprima = raw_input("Digite o texto que pretende que o programa imprima no início (sugestão: refira os nomes das teclas que iniciam o SO(ENTER) ou o menu da BIOS(B)):")
                                import os
                                reescrever = os.remove('maquina virtual 1ªversão-texto inicial.txt')
                                restarting = open('maquina virtual 1ªversão-texto inicial.txt', 'w')
                                save = raw_input("Guardar alterações?")
                                if save == "sim" or save == "si" or save == "s".lower():
                                     if (len(imprima) > 0):
                                        restarting.write(imprima)
                                        restarting.close()
                                     else:
                                        print "Não digitou nenhum texto."
                                        bios()
                                else:
                                    print "Não foram guardadas quaisquer alterações(de texto: o ficheiro ficou sem nenhum texto)."
                                rebobinar = raw_input("")
                                if rebobinar == "back" or rebobinar == "b" or rebobinar == "":
                                    bios()
                            elif alterar == "Apresentar código de arranque" or alterar == "b".lower():
                                #código ainda não concluído
                                if rebobinar == "back" or rebobinar == "b" or rebobinar == "":
                                    bios()
                                else:
                                    bios()
                            else:
                                bios()
                        elif avanced == "Desinstalar SO" or avanced == "b".lower():
                            deletar_so = raw_input("Tem mesmo a certeza (atenção: depois não pode restaurar e pode perder dados)?)")
                            if deletar_so == "sim" or deletar_so == "yes":
                                    print "A desinstalar o SO..."
                                    import time
                                    time.sleep(20)
                                #função bitsky_one--> deletar
                                    print "SO desinstalado."
                            else:
                                bios()
                        elif avanced == "Criar permissões especiais para a VM" or avanced == "c".lower():
                            especial = raw_input("As opções disponíveis são: \nColocar password(a) \nEliminar password(b)")
                            if especial == "Colocar password" or especial == "a":
                               criar_passe_vm()
                            elif especial == "Eliminar password" or especial == "b":
                                try:
                                    ter = raw_input("Tem mesmo a certeza?")
                                    if ter == "sim" or ter == "si" or ter == "s".lower():
                                        save = raw_input("Guardar alterações?")
                                        if save == "sim" or save == "si" or save == "s".lower():
                                            import os 
                                            sem_passe = os.remove("Password VM.txt")    
                                        else:
                                            print "Não foram guardadas nenhumas alterações."
                                            bios()
                                    else:
                                        bios()
                                except WindowsError:
                                    print "A palavra passe já foi removida anteriormente."
                                    bios()
                            else:
                                bios()
                        elif avanced == "Informações de Hardware" or avanced == "e":
                            import platform
                            so = platform.system()
                            arq_processador = platform.machine()
                            nome_pc = platform.node()
                            windows = platform.platform()
                            print "Sistema Operacional: %s" % (so)
                            print "Arquitetura do processador: %s" % (arq_processador)
                            print "Nome do computador: %s" % (nome_pc)
                            print "Informações do windows: %s" % (windows)
                        else:
                            bios()
                        rebobinar = raw_input("")
                        if rebobinar == "back" or rebobinar == "b" or rebobinar == "":
                                bios()
                        else:
                            bios()
                    else:
                       bios()
                elif opcao == "quit" or opcao == "Q".upper():
                    arranque()
                elif opcao == "Configurações do SO" or opcao == "d".lower():
                    alteracao = raw_input("As opções disponíveis são: \nModificar o tempo de boot do SO(a) \nFormatar SO(b)")
                    if alteracao == "Modificar o tempo de boot do SO" or alteracao == "a":
                        alterar_boot = raw_input("Insira o tempo que deseja que o SO demore a iniciar:\n")
                        try:
                            alterar_boot = float(alterar_boot)
                        except ValueError or TypeError:
                            print "Digite um número inteiro positivo maior ou igual a 20!"
                            bios()
                        if alterar_boot >= 20:
                            print "Valor de tempo suportado."
                            save = raw_input("Guardar alterações?")
                            if save == "sim" or save == "si" or save == "s".lower():
                                guardarTempoBoot(alterar_boot)
                            rebobinar = raw_input("")
                            if rebobinar == "back" or rebobinar == "b" or rebobinar == "":
                                bios()
                            else:
                                bios()
                    elif alteracao == "Formatar SO" or alteracao == "b":
                       raise None #Só pode ser concluído quando for feito o SO
                    else:
                        bios()
                else:
                    bios()
            bios()
            #bios=============================================================================================================
        elif machine == "" or inp:
            import time
            if temp >=20:
                print "A iniciar o PowerBIT 1.0..."
                starting_so = time.sleep(float(temp))
                while starting_so:
                    text_y()
                    if (str(text_z)) == "def bios(): right (0b10b100b110b100)":
                        pass
                    else:
                        print "ERRO DE PARTIÇÃO: o SO não foi localizado. Poderá estar em falta a Chave correta de inicialização do SO ou pode estar corrompido."
                    try:
                        import os
                        os.remove("reiniciar.txt")
                    except:
                        pass
                    user_y()
                    entrada_y()
                    programas_y()                   
            else:
                time.sleep(30)
                print "A iniciar o PowerBIT 1.0..."
                starting_so = time.sleep(float(temp))
                while starting_so:
                    text_y()
                    if (str(text_z)) == "def bios(): right (0b10b100b110b100)":
                        pass
                    else:
                        print "ERRO DE PARTIÇÃO: o SO não foi localizado. Poderá estar em falta a Chave correta de inicialização do SO ou pode estar corrompido."
                    try:
                        import os
                        os.remove("reiniciar.txt")
                    except:
                        pass
                    user_y()
                    entrada_y()
                    programas_y()                
            def powerbit():
                print "====================================================================="
                print "                       PowerBIT v.1.0"
                print "====================================================================="
                print "Escolha um utilizador:"
                print user_z
                palavra_passe_os()
                print "Bem vindo!"
            powerbit()
        elif machine == "quit" or machine == "exit" or machine == "e" or machine == "q":
            quit()
        else:
            arranque()
    arranque()

I’m sorry if I didn’t mention the code enough and the code is disorganized. I use windows 7 and the python version I use is python 2.7.6.

  • Hello @Henrique, if this is a fix, you could have edited the previous question or deleted it, since no unanswered questions are desired in the community or unnecessary duplication.

  • @Caputo, I edited my previous question but ended up changing it radically. So I created this as a correction of the previous one.

  • 1

    @Caputo, the previous question was debated at the Meta.

1 answer

6


Once you are in Windows the module msvcrt (English) is suitable to keep an eye on the user’s I/O in order to interrupt the waiting time:

def wait_for_user(segundos):

    import msvcrt
    import time

    start = time.time()

    while True:
        if msvcrt.kbhit():
            msvcrt.getch()
            break
        if time.time() - start > segundos:
            break

        time.sleep(0.2) # "dormir" durante 200 milissegundos (*)

User solutions credit @Brendenbrown in this answer in the SOEN.


Original Solution

A solution making use of the module select (English) to wait 2 seconds but keep an eye on the user’s I/O:

Unix/Linux

import sys
from select import select

print "Prima qualquer tecla para continuar ou aguarde 2 segundos..."
timeout = 2
rlist, wlist, xlist = select([sys.stdin], [], [], timeout)

if rlist:
    print "A iniciar o PowerBIT 1.0..."
else:
    print "Tempo expirou..."

Windows

For windows the appropriate module for this purpose is the msvcrt (English) which will likewise be attentive to the user’s I/O:

import sys, time, msvcrt

timeout = 2
startTime = time.time()
inp = None

print "Prima qualquer tecla para continuar ou aguarde 2 segundos..."
while True:
    if msvcrt.kbhit():
        inp = msvcrt.getch()
        break
    elif time.time() - startTime > timeout:
        break

    time.sleep(0.2) # "dormir" durante 200 milissegundos (*)

if inp:
    print "A iniciar o PowerBIT 1.0..."
else:
    print "Tempo expirou..."

User solutions credit @Bryan in this answer in the SOEN.


(*) As a reminder from @jsbueno CPU occupation triggers compromisingly while the while True is running.

To reduce this occupation to acceptable values, we can use a time.sleep(x).

In this answer of SOEN the user @gnibbler presented some tests in order to calculate reference values:

Initial test:

import time
while True: time.sleep(0.2)      # 0% CPU
while True: time.sleep(0.02)     # 0% CPU
while True: time.sleep(0.002)    # 0.5% CPU
while True: time.sleep(0.0002)   # 6% CPU
while True: time.sleep(0.00002)  # 18% CPU

Test with extra work on loop:

import time
while True: range(10000) and None; time.sleep(0.2)      # 1% CPU
while True: range(10000) and None; time.sleep(0.02)     # 15% CPU
while True: range(10000) and None; time.sleep(0.002)    # 60% CPU
while True: range(10000) and None; time.sleep(0.0002)   # 86% CPU
  • I’ll test the code :)

  • Thank you for your reply. Unfortunately it did not give the intended, this because when 2 seconds pass it still does not print "Starting Powerbit 1.0..." and waiting for the user to load enter.

  • I edited the question by also adding the source code.

  • @Henrique You are using cmd or IDLE ?

  • I’m using the IDLE.

  • 1

    @Henrique Pois does not work in IDLE, only in cmd prompt! You should add details of this nature to your question through tags or in the body of the same... It is important to know your work environment for a suitable solution.

  • It happens to me backwards: it gives in IDLE and does not give in cmd.

  • @Henrique I added another version that can solve your case!

  • So after creating this function I need to call it in the Elif statement to work?

  • 2

    Zuul: beware of the loop while True: solution for Windows. From the jetio that is there, it will use 100% of the CPU - even if only for two seconds - the ideal is to leave a pause - you can even use the.Leep team, for 30ms for example, within a loop of these.

  • @Zuul, Thanks ;) Just out of curiosity: it would be possible to use threads for the same effect (I’ve been doing some research on python threads)?

Show 6 more comments

Browser other questions tagged

You are not signed in. Login or sign up in order to post.