Ir ao conteúdo
  • Cadastre-se
Entre para seguir isso  
Nerun

Phyton

Recommended Posts

1) se eu tenho que fazer uma equação que tenha como resultado um número não inteiro, como eu faço para arredondar para o próximo número inteiro (arredondar sempre para cima)?

Ex.:

a = qualquer número fornecido pelo usuário

b = a / 750

nessa equação, se a for 7000, b será 9.3333..., mas se eu der print o que aparece é apenas 9, mas eu quero que arredonde sempre para cima (seria 10 no caso), como faço?

2) Eu tenho um dicionário, por exemplo:

dic = {}

O primeiro é o objeto, o segundo é a quantidade. Agora, digamos que eu tenho as seguintes listas:

Cenoura = [1, 0.5]
Alho = [5, 0.05]
Arroz = [10, 0.005]

Nesta ordem: custo por kilo, peso de cada um individualmente (esses valores não são reais, são só exemplo)

assim, se eu quiser imprimir num arquivo o custo e o peso final para cada item e quantidade escolhido, eu faço assim:

    nave.write("\Lista de compras:")
   for x, y in dic.items():
       if x == "Cenoura":
           a1 = Cenoura[0]*y
           b1 = Cenoura[1]*y
       elif x == "Alho":
           a1 = Alho[0]*y
           b1 = Alho[1]*y
       elif x == "Arroz":
           a1 = Arroz[0]*y
           b1 = Arroz[1]*y

nave.write("\n [ %s ] %s (total: $%s, %skg)"% (y, x, a1, b1))

Se um cara tiver comprado o seguinte:

dic = {cenoura:2, alho:4, arroz:1}

Será impresso o seguinte:

[2] Cenoura (total: $2, 1kg)

[4] Alho (total: $20, 0.2kg)

[1] Arroz (total: $10, 0.005kg)

Testei isso e funciona, agora vem a pergunta:

E se eu quiser somar todos os b1 (os kilos)?

Por exemplo, no exemplo acima eu teria total dos b1 = 1.205kg

Mas o problema, é que o dicionário muda á cada uso, então como somar os b1? Entenderam? To quebrando a cabeça aqui...

Compartilhar este post


Link para o post
Compartilhar em outros sites

Colega, eu não conheço python, mas mesmo assim você pode fazer o seguinte:

1) Você pode fazer alguma rotina para descobrir se o número é inteiro ou não. Por exemplo, se o tamanho do valor digitado pelo usuário não pode ultrapassar 32 mil e alguma coisa (uma variável inteira no C), você pode fazer (vou fazer a rotina em C, que é bem fácil, e você adapta ela):



\\32000 (limite) / 750 (valor que você quer dividir) = 42,xx. Vamos usar 45
for (i=0;i<=45;i++) { // laço para verificação
  if (i*750 == a) { //o número é inteiro
    b = a / 750; // mostra o número normalmente
    goto proxima_funcao; // termina o laço for aqui
  } else { //senão
     if (i == 45) { // se for o ultimo valor e não encontrou nenhum resultado
        b = a / 750 + 1;
     }
  }
}

proxima_funcao:
resto do programa


Eu acho provável que isso se possa fazer. Eu admito que não é a melhor forma de se fazer, mas é uma solução.

2) Novamente, aí vai uma artimanha que você pode usar, mas como não conheço python, tudo é possível: Crie uma variável 'somab1' e a cada linha vai somando, alguma coisa parecida com isso:

  nave.write("\Lista de compras:")
  for x, y in dic.items():
      if x == "Cenoura":
          a1 = Cenoura[0]*y
          b1 = Cenoura[1]*y
          somab1 = somab1 + b1
      elif x == "Alho":
          a1 = Alho[0]*y
          b1 = Alho[1]*y
          somab1 = somab1 + b1
      elif x == "Arroz":
          a1 = Arroz[0]*y
          b1 = Arroz[1]*y
          somab1 = somab1 + b1
nave.write("\n [ %s ] %s (total: $%s, %skg)"% (y, x, a1, b1))

Agora, se você quiser apenas mostrar a quantidade total, tente fazer o seguinte:

  nave.write("\Lista de compras:")
  for x, y in dic.items():
      if x == "Cenoura":
          a1 = Cenoura[0]*y
          b1 = Cenoura[1]*y
      elif x == "Alho":
          a1 = Alho[0]*y
          b1 = Alho[1]*y + b1
      elif x == "Arroz":
          a1 = Arroz[0]*y
          b1 = Arroz[1]*y + b1
nave.write("\n [ %s ] %s (total: $%s, %skg)"% (y, x, a1, b1))

Bom, eu não conheço python, mas acho que isso pode funcionar.

Espero ter ajudado,

Gustavo

Compartilhar este post


Link para o post
Compartilhar em outros sites

Testei e utilizar somab1 = somab1 + b1 não funciona, porque somab1 não está definido.

Alguma outra sugestão?

Compartilhar este post


Link para o post
Compartilhar em outros sites

Bom, como eu disse, não conheço python. O que eu sei mexer é com C e VB, mas talvez a solução dos problemas seja a mesma:

Verifique se você realmente declarou somab1. Várias vezes já pensei em uma variável e fiz o programa inteiro sem declará-la.

Qualquer coisa, tente declarar uma variavel temp. Eu não sei como funciona no python, mas no C seria mais ou menos assim:


a = 5;
soma = 0;

soma = soma + a;      //soma = 0 + 5

Se por um acaso qualquer o python não aceita isso, crie uma variavel temporaria, se bem que acho isso meio improvável de acontecer.


a = 5;
soma = 0;
temp = soma;
soma = temp + a;

Provavelmente o seu problema deve ser alguma coisa na hora de declarar a variável, mas qualquer coisa poste aí.

Espero ter ajudado.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Funcionou mais ou menos. Do jeito que está embaixo, ele soma pra cada um individulamente, eu quero que some todos.

O que eu obtive:

 [ 10 ] MEM (total: 1.0t, 3.7m3, $4000, 0MW)
Volume das Armas e Munição: [ 3.7 ]
[ 10 ] MEL (total: 0.3t, 0.9m3, $2000, 0MW)
Volume das Armas e Munição: [ 0.9 ]
[ 1 ] LML (total: 0.5t, 1.5m3, $5000, 0MW)
Volume das Armas e Munição: [ 1.5 ]
[ 1 ] LMM (total: 1t, 2.25m3, $10000, 0MW)
Volume das Armas e Munição: [ 2.25 ]

PS.: b1 aqui no caso é o volume, em metros cúbicos (m3).

O que eu quero é isso:

 [ 10 ] MEM (total: 1.0t, 3.7m3, $4000, 0MW)
[ 10 ] MEL (total: 0.3t, 0.9m3, $2000, 0MW)
[ 1 ] LML (total: 0.5t, 1.5m3, $5000, 0MW)
[ 1 ] LMM (total: 1t, 2.25m3, $10000, 0MW)
Volume das Armas e Munição: [ 8.35 ]

Entende? Que some todos, e não cada um separadamente, porque eu já forneço o total pra cada um (...total: 1.0t, 3.7m3, $4000, 0MW...), isto já é a soma da quantidade especificada e não separadamente.

Alguma ideia?

Trecho de código usado:

    nave.write("\nArmamento e Munição:")
   for x, y in ArmEsc.items():
   # genéricos (não variam com NT)
       #armas
       somab1 = 0
       if x == "CAAC":
           a1 = eCAAC[1]*y
           b1 = eCAAC[2]*y
           c1 = eCAAC[0]*y
           d1 = eCAAC[4]*y
           somab1 = somab1 + b1
       elif x == "LML":
           a1 = eLML[1]*y
           b1 = eLML[2]*y
           c1 = eLML[0]*y
           d1 = eLML[4]*y
           somab1 = somab1 + b1
       elif x == "LMM":
           a1 = eLMM[1]*y
           b1 = eLMM[2]*y
           c1 = eLMM[0]*y
           d1 = eLMM[4]*y
           somab1 = somab1 + b1
       elif x == "LMP":
           a1 = eLMP[1]*y
           b1 = eLMP[2]*y
           c1 = eLMP[0]*y
           d1 = eLMP[4]*y
           somab1 = somab1 + b1
       elif x == "FD":
           a1 = eFD[1]*y
           b1 = eFD[2]*y
           c1 = eFD[0]*y
           d1 = eFD[4]*y
           somab1 = somab1 + b1
       #munição
       elif x == "CALM":
           a1 = eCALM[1]*y
           b1 = eCALM[2]*y
           c1 = eCALM[0]*y
           d1 = 0
           somab1 = somab1 + b1
   # específicos (variam com NT)
       #armas
       else:
           if NT == 7: #munição apenas
               if x == "MEL":
                   a1 = eMEL[1]*y
                   b1 = eMEL[2]*y
                   c1 = eMEL[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEM":
                   a1 = eMEM[1]*y
                   b1 = eMEM[2]*y
                   c1 = eMEM[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEP":
                   a1 = eMEP[1]*y
                   b1 = eMEP[2]*y
                   c1 = eMEP[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAL":
                   a1 = eMAL[1]*y
                   b1 = eMAL[2]*y
                   c1 = eMAL[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAM":
                   a1 = eMAM[1]*y
                   b1 = eMAM[2]*y
                   c1 = eMAM[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAP":
                   a1 = eMAP[1]*y
                   b1 = eMAP[2]*y
                   c1 = eMAP[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
           if NT == 8:
               #armas
               if x == "LME":
                   a1 = eLME[1]*y
                   b1 = eLME[2]*y
                   c1 = eLME[0]*y
                   d1 = eLME[4]*y
                   somab1 = somab1 + b1
               elif x == "LL":
                   a1 = eLL[1]*y
                   b1 = eLL[2]*y
                   c1 = eLL[0]*y
                   d1 = eLL[4]*y
                   somab1 = somab1 + b1
               elif x == "LM":
                   a1 = eLM[1]*y
                   b1 = eLM[2]*y
                   c1 = eLM[0]*y
                   d1 = eLM[4]*y
                   somab1 = somab1 + b1
               elif x == "FP":
                   a1 = eFP[1]*y
                   b1 = eFP[2]*y
                   c1 = eFP[0]*y
                   d1 = eFP[4]*y
                   somab1 = somab1 + b1
               #munição
               elif x == "MEL":
                   a1 = eMEL1[1]*y
                   b1 = eMEL1[2]*y
                   c1 = eMEL1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEM":
                   a1 = eMEM1[1]*y
                   b1 = eMEM1[2]*y
                   c1 = eMEM1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEP":
                   a1 = eMEP1[1]*y
                   b1 = eMEP1[2]*y
                   c1 = eMEP1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAL":
                   a1 = eMAL1[1]*y
                   b1 = eMAL1[2]*y
                   c1 = eMAL1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAM":
                   a1 = eMAM1[1]*y
                   b1 = eMAM1[2]*y
                   c1 = eMAM1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAP":
                   a1 = eMAP1[1]*y
                   b1 = eMAP1[2]*y
                   c1 = eMAP1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
           elif NT == 9:
               #armas
               if x == "LME":
                   a1 = eLME[1]*y
                   b1 = eLME[2]*y
                   c1 = eLME[0]*y
                   d1 = eLME[4]*y
                   somab1 = somab1 + b1
               elif x == "LL":
                   a1 = eLL1[1]*y
                   b1 = eLL1[2]*y
                   c1 = eLL1[0]*y
                   d1 = eLL1[4]*y
                   somab1 = somab1 + b1
               elif x == "LM":
                   a1 = eLM1[1]*y
                   b1 = eLM1[2]*y
                   c1 = eLM1[0]*y
                   d1 = eLM1[4]*y
                   somab1 = somab1 + b1
               elif x == "LP":
                   a1 = eLP[1]*y
                   b1 = eLP[2]*y
                   c1 = eLP[0]*y
                   d1 = eLP[4]*y
                   somab1 = somab1 + b1
               elif x == "FP":
                   a1 = eFP1[1]*y
                   b1 = eFP1[2]*y
                   c1 = eFP1[0]*y
                   d1 = eFP1[4]*y
                   somab1 = somab1 + b1
               elif x == "FPP":
                   a1 = eFPP[1]*y
                   b1 = eFPP[2]*y
                   c1 = eFPP[0]*y
                   d1 = eFPP[4]*y
                   somab1 = somab1 + b1
               #munição
               elif x == "MEL":
                   a1 = eMEL2[1]*y
                   b1 = eMEL2[2]*y
                   c1 = eMEL2[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEM":
                   a1 = eMEM2[1]*y
                   b1 = eMEM2[2]*y
                   c1 = eMEM2[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEP":
                   a1 = eMEP2[1]*y
                   b1 = eMEP2[2]*y
                   c1 = eMEP2[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAL":
                   a1 = eMAL2[1]*y
                   b1 = eMAL2[2]*y
                   c1 = eMAL2[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAM":
                   a1 = eMAM2[1]*y
                   b1 = eMAM2[2]*y
                   c1 = eMAM2[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAP":
                   a1 = eMAP2[1]*y
                   b1 = eMAP2[2]*y
                   c1 = eMAP2[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
           elif NT == 10:
               #armas
               if x == "LMEL":
                   a1 = eLMEL[1]*y
                   b1 = eLMEL[2]*y
                   c1 = eLMEL[0]*y
                   d1 = eLMEL[4]*y
                   somab1 = somab1 + b1
               elif x == "LME":
                   a1 = eLME[1]*y
                   b1 = eLME[2]*y
                   c1 = eLME[0]*y
                   d1 = eLME[4]*y
                   somab1 = somab1 + b1
               elif x == "LL":
                   a1 = eLL2[1]*y
                   b1 = eLL2[2]*y
                   c1 = eLL2[0]*y
                   d1 = eLL2[4]*y
                   somab1 = somab1 + b1
               elif x == "LM":
                   a1 = eLM2[1]*y
                   b1 = eLM2[2]*y
                   c1 = eLM2[0]*y
                   d1 = eLM2[4]*y
                   somab1 = somab1 + b1
               elif x == "LP":
                   a1 = eLP1[1]*y
                   b1 = eLP1[2]*y
                   c1 = eLP1[0]*y
                   d1 = eLP1[4]*y
                   somab1 = somab1 + b1
               elif x == "FP":
                   a1 = eFP2[1]*y
                   b1 = eFP2[2]*y
                   c1 = eFP2[0]*y
                   d1 = eFP2[4]*y
                   somab1 = somab1 + b1
               elif x == "FPP":
                   a1 = eFPP1[1]*y
                   b1 = eFPP1[2]*y
                   c1 = eFPP1[0]*y
                   d1 = eFPP1[4]*y
                   somab1 = somab1 + b1
               #munição
               elif x == "MEL":
                   a1 = eMEL3[1]*y
                   b1 = eMEL3[2]*y
                   c1 = eMEL3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEM":
                   a1 = eMEM3[1]*y
                   b1 = eMEM3[2]*y
                   c1 = eMEM3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEP":
                   a1 = eMEP3[1]*y
                   b1 = eMEP3[2]*y
                   c1 = eMEP3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAL":
                   a1 = eMAL3[1]*y
                   b1 = eMAL3[2]*y
                   c1 = eMAL3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAM":
                   a1 = eMAM3[1]*y
                   b1 = eMAM3[2]*y
                   c1 = eMAM3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAP":
                   a1 = eMAP3[1]*y
                   b1 = eMAP3[2]*y
                   c1 = eMAP3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
           elif NT == 11:
               #armas
               if x == "LMEL":
                   a1 = eLMEL1[1]*y
                   b1 = eLMEL1[2]*y
                   c1 = eLMEL1[0]*y
                   d1 = eLMEL1[4]*y
                   somab1 = somab1 + b1
               elif x == "LME":
                   a1 = eLME1[1]*y
                   b1 = eLME1[2]*y
                   c1 = eLME1[0]*y
                   d1 = eLME1[4]*y
                   somab1 = somab1 + b1
               elif x == "LL":
                   a1 = eLL2[1]*y
                   b1 = eLL2[2]*y
                   c1 = eLL2[0]*y
                   d1 = eLL2[4]*y
                   somab1 = somab1 + b1
               elif x == "LM":
                   a1 = eLM2[1]*y
                   b1 = eLM2[2]*y
                   c1 = eLM2[0]*y
                   d1 = eLM2[4]*y
                   somab1 = somab1 + b1
               elif x == "LP":
                   a1 = eLP1[1]*y
                   b1 = eLP1[2]*y
                   c1 = eLP1[0]*y
                   d1 = eLP1[4]*y
                   somab1 = somab1 + b1
               elif x == "FP":
                   a1 = eFP3[1]*y
                   b1 = eFP3[2]*y
                   c1 = eFP3[0]*y
                   d1 = eFP3[4]*y
                   somab1 = somab1 + b1
               elif x == "FPP":
                   a1 = eFPP2[1]*y
                   b1 = eFPP2[2]*y
                   c1 = eFPP2[0]*y
                   d1 = eFPP2[4]*y
                   somab1 = somab1 + b1
               #munição
               elif x == "MEL":
                   a1 = eMEL3[1]*y
                   b1 = eMEL3[2]*y
                   c1 = eMEL3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEM":
                   a1 = eMEM3[1]*y
                   b1 = eMEM3[2]*y
                   c1 = eMEM3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEP":
                   a1 = eMEP3[1]*y
                   b1 = eMEP3[2]*y
                   c1 = eMEP3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAnL":
                   a1 = eMAnL[1]*y
                   b1 = eMAnL[2]*y
                   c1 = eMAnL[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAnM":
                   a1 = eMAnM[1]*y
                   b1 = eMAnM[2]*y
                   c1 = eMAnM[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAnP":
                   a1 = eMAnP[1]*y
                   b1 = eMAnP[2]*y
                   c1 = eMAnP[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
           elif NT >= 12:
               #armas
               if x == "LMEL":
                   a1 = eLMEL2[1]*y
                   b1 = eLMEL2[2]*y
                   c1 = eLMEL2[0]*y
                   d1 = eLMEL2[4]*y
                   somab1 = somab1 + b1
               elif x == "LME":
                   a1 = eLME2[1]*y
                   b1 = eLME2[2]*y
                   c1 = eLME2[0]*y
                   d1 = eLME2[4]*y
                   somab1 = somab1 + b1
               elif x == "LL":
                   a1 = eLL2[1]*y
                   b1 = eLL2[2]*y
                   c1 = eLL2[0]*y
                   d1 = eLL2[4]*y
                   somab1 = somab1 + b1
               elif x == "LM":
                   a1 = eLM2[1]*y
                   b1 = eLM2[2]*y
                   c1 = eLM2[0]*y
                   d1 = eLM2[4]*y
                   somab1 = somab1 + b1
               elif x == "LP":
                   a1 = eLP1[1]*y
                   b1 = eLP1[2]*y
                   c1 = eLP1[0]*y
                   d1 = eLP1[4]*y
                   somab1 = somab1 + b1
               elif x == "FP":
                   a1 = eFP4[1]*y
                   b1 = eFP4[2]*y
                   c1 = eFP4[0]*y
                   d1 = eFP4[4]*y
                   somab1 = somab1 + b1
               elif x == "FPP":
                   a1 = eFPP3[1]*y
                   b1 = eFPP3[2]*y
                   c1 = eFPP3[0]*y
                   d1 = eFPP3[4]*y
                   somab1 = somab1 + b1
               #munição
               elif x == "MEL":
                   a1 = eMEL3[1]*y
                   b1 = eMEL3[2]*y
                   c1 = eMEL3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEM":
                   a1 = eMEM3[1]*y
                   b1 = eMEM3[2]*y
                   c1 = eMEM3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MEP":
                   a1 = eMEP3[1]*y
                   b1 = eMEP3[2]*y
                   c1 = eMEP3[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAnL":
                   a1 = eMAnL1[1]*y
                   b1 = eMAnL1[2]*y
                   c1 = eMAnL1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAnM":
                   a1 = eMAnM1[1]*y
                   b1 = eMAnM1[2]*y
                   c1 = eMAnM1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1
               elif x == "MAnP":
                   a1 = eMAnP1[1]*y
                   b1 = eMAnP1[2]*y
                   c1 = eMAnP1[0]*y
                   d1 = 0
                   somab1 = somab1 + b1

       nave.write("\n [ %s ] %s (total: %st, %sm3, $%s, %sMW)"% (y, x, a1, b1, c1, d1))
       nave.write("\n Volume das Armas e Munição: [ %s ]"% somab1)

Compartilhar este post


Link para o post
Compartilhar em outros sites

Pra arredondar pra cima tente assim...

1 - faça as contas em float (escrevendo por exemplo 17.0/3.0). COloque o .0 daí ele entende que é float.

2 - some 0.5 daí faça o int()

Entendeu?

No seu caso

a = qualquer número fornecido pelo usuário

b = a / 750.0

c = int(b+0.5)

Daí c teria o valor arredondado

Compartilhar este post


Link para o post
Compartilhar em outros sites

esquece, consegui, declarei somab1 no lugar errado:

   nave.write("\nArmamento e Munição:")
  for x, y in ArmEsc.items():
  # genéricos (não variam com NT)
      #armas
      somab1 = 0
      if x == "CAAC":
          a1 = eCAAC[1]*y
          b1 = eCAAC[2]*y
          c1 = eCAAC[0]*y
          d1 = eCAAC[4]*y
          somab1 = somab1 + b1
      elif x == "LML":
...

Tenho q declarar fora do for x, y ..., como fiz aqui:

   nave.write("\nArmamento e Munição:")
  somab1 = 0
  for x, y in ArmEsc.items():
  # genéricos (não variam com NT)
      #armas
      if x == "CAAC":
          a1 = eCAAC[1]*y
          b1 = eCAAC[2]*y
          c1 = eCAAC[0]*y
          d1 = eCAAC[4]*y
          somab1 = somab1 + b1
      elif x == "LML":
...

valeu, obrigado por tudo, e pela paciência. :D

Compartilhar este post


Link para o post
Compartilhar em outros sites
Postado Originalmente por tabgal@26 jun 2004, 21:24

Pra arredondar pra cima tente assim...

a = qualquer número fornecido pelo usuário

b = a / 750.0

c = int(b+0.5)

Pelo que vi aqui melhor é fazer:

a = qualquer número fornecido pelo usuário

b = a / 750.0

c = b+0.5

d = round(c,0)

O int não funciona adequadamente neste caso. Por exemplo, o round sempre aredonda usando a notação matemática, ou seja, até 4 pra baixo, de 5 pra cima, arredonda pra cima. Exemplo:

b = 1.1

c será = 1.6

round(c,0) será = 2.0

OK

b = 1.5

c será = 2.0

round(c,0) será = 2.0

OK

b = 1.9

c será = 2.4

round(c,0) será = 2.0

OK

Isto equivale a arredondar sempre para cima, como eu queria, mesmo que o resultado seja próximo do numero mais baixo, como 1.1.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora
Entre para seguir isso  





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×