Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
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

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

×