Jump to content

geovaniif

Pessoal da TecnoSpeed
  • Contagem de Conteúdo

    40
  • Ingressou

  • Última visita

  • Dias Ganhos

    2

Postagens postado por geovaniif

  1. Oi!

     

    Cara posso ter entendido errado, mas eu acho que vc quer pegar o indice do dataframe que o maior valor pertence, correto? Tipo, qual a linha do dataframe que ele ta, correto?

     

    Se for isso, acontece que vc está tentando chamar o index de um array ali no seu print.

    Teria que ser values[0].index(max_values)

    entretanto toda via, isso ainda não vai te ajudar pois o dataframe não tem esse função index que eu me lembre. Se vc quer pegar o registro da linha do max_values, é melhor filtrar fazendo

    values[0][values[0]["A1'"] == max_values].index[0]

     

  2. ata, entendi!

    cara, é MUITO parecido com R. Eu costumo criar um dicionario, que parece um json

    algo desse tipo:

    meu_dicionario = {
      "empresa" : [1,2,3,4],
      "latitude" : [v1, v2, v3, v4],
      "longitude" : [l1, l2, l3, l4],
    }
    #coloquei v1 v2 l1 l2 pq fiquei com preguiça de ver os valores
    
    meu_dataframe = pd.DataFrame(meu_dicionario)

     

    você também pode colocar direto na função DataFrame ao invez de criar variavel (da mesma forma que vc fez em R). Só separei pra ficar mais claro

    • Curtir 1
  3. 17 horas atrás, TheusBarboza disse:

    Aah Obrigado Geovani, ajudou bastante, já estava  há um tempão procurando essa solução.
    Não, não vou precisar das 2 mil linhas, vou precisar das mais relevantes, e pensando nessa relevância, como posso fazer para ele me retornar em ordem decrescente?

    meu_dataframe.sort_values(by='coluna_que_desejo_ordenar', ascending=True)
    #mudar o ascending para false para ordenar de forma decrescente 

     

  4. oi!

    cara, pode ser muita coisa, massss uma das coisas que pode ser é que o seu join está removendo os registros com o sts_cats_artigo_id = 1

    Isso não significa que seu join está errado, um join pode remover linhas, é normal. Uma coisa que vc pode fazer é trocar o inner por left. Dessa forma, o join não vai remover esses registros, mas as colunas da tabela da deireita estaram nulos caso ele não encontra um match com a da esquerda.

    Faça isso, muda pra left e verifica se vem algo. Se vier algo e esse algo tiver os campos da tabela da direita nulos, basicamente o seu inner join removi ele pois não acontece o match

  5. Oi!

     

    Cara isso é incrivelmente simples de resolver (amém)

    é uma config do pandas, basicamente ele tem um limte de linhas padrão que ele mostra (e de colunas também!)

    existe 2 formas de resolver: A que é uma solução de contorno, e a definiditiva

    a contorno, é vc usar a função head ou tail e informar o numero de linhas

    ex:

    #essa opção vai printar as primeiras 50 linhas do datafarme
    print(faturamentoProduto.head(50))
    
    #essa vai printar as ultimas 50
    print(faturamentoPorduto.head(50))

     

    a definitiva, que não necessariamente é a melhor, é alterar o displaymax do pandas

    pq não necessariamente é a melhor?

    ora, vi que seu dataframe tem quase 2mil linhas... vc REALMENTE quer printar 2mil linhas? 🤨

    bom, fica por sua conta e risco, mas é assim


     

    #esse codigo vai tirar esse limite de linhas, mostrando todas elas.
    #Você também pode simplismente aumentar esse limite, trocando o None por um novo limite, como por exemplo 50
    pd.set_option('display.max_rows', None)
    #deixando o limite de linhas com 50
    pd.set_option('display.max_rows', 50)
    
    
    #Para fazer a mesma coisa com colunas, basta usar o max_columns
    pd.set_option('display.max_columns', None)

     

     

    tenta ai e me avisa!

  6. 1 hora atrás, RamiroJunior1 disse:

    Desculpe-me por ser meio leigo, estou aprendendo python tem apenas alguns dias.
    Consegue explicar como faze-lo ? 

    claro!

    vamos supor que o seu dataframe chama-se "df" e que a coluna que é uma data chama-se 'minha_data'

    df['minha_data'] = (df['minha_data']).astype(str)

     

  7. Oi!

    Claro! vc QUASE fez isso. 

    o termo return basicamente retorna um valor lá pra onde a função foi chamada... e é exatamente isso que vc quer!

    A sua função no momento faz um return de nada, mas se simplismente trocar a palavra print por return, ao invez de printar o texto, ele vai retornar o texto e atribuar para a variavel classificação

    tenta ai!

  8. Oi!

     

    Tem um errinho de lógica no seu algoritmo.

     

    Vamos fazer um teste de mesa:

    1. ok, tem o print bonitinho e entra num loop "infinito"
    2. Pega as 3 medidas (2,3,4)
    3. verifica se a < b+c e da um resposta adequada pra saber se faz um triangulo (2 < 3+4 -> TRUE, vai printar que é um triangulo)
    4. pergunta se quer informar novos valores (vou digitar "batata doce")
    5. verifica se a resposta é não. Caso seja, interrompe o loop. (não é, pois digitei batata doce)
    6. Verifica se a respota é diferente de "sim". Caso seja, pergunta novamente. (é diferente de sim, então entar no if e pergunta novamente)
    7. notifica que nao entendeu e pergunta novamente. (Escrevo "batata frita")
    8. fim do codigo, volta para a linha do while true e repete tudo novamente.
    9. Pega 3 medidas (10,20,10)
    10. 10<20+10? sim, fala que é um triganulo
    11. quer mais valores? "n"
    12. fala que nao entendeu e pergunta novamente "ñ"
    13. volta pro while e repete tudo...

     

    Percebeu o erro? A sua verificação verifica só 1 vez, quando na verdade ela deve ficar verificando até digitar algo válido

  9. sobre o numero de linhas no losango, basta alterar a iteração de numero de linhas

    while i < N+1: ### <- essa iteração é do numero de linhas
        for j in range(1,N-i+1): ## <- essa é do numero de espaços
            print(" ", end="")
        for j in range(1, 2*i): # <- essa é pra descobrir onde colocar os *
            if j==1 or j==2*i-1:
                print("**", end="")
            else: print(" ", end="")
    
        i = i + 1
        j = j + 1
    
        print() # <- esse print sever pra gerar uma linha nova
    # logo, podemos ver que ele vai até N+1. Quando N é 6, ele vai até 7. Se vc quer mudar pra ir até 5, bastar fazer N-1 na iterção    

     

  10. oi!

    certo, usar o for com range ou usar um while com um contador vc chega no mesmo resultado, é bem facil não usar o range. A gente usa o range quando sabemos a quantidade de iterações que queremos ter, e geralmente usamos o while quando não sabemos, mas, da pra fazer um if dentro do while pra ele ser interrompido. ex:

    todas as forma abaixo contam até 10. Tenta mudar o seu for range pelo while com a condição.

    ###### usando range #####
    for i in range(10):
    	print(i)
    
    ##### usando while com condição #####
    contador = 0
    while contador < 10:
    	print(contador)
        contador += 1
        
    #### usando while com break #######
    x = 0
    while True:
    	if x >= 10:
    		break
    	print(x)
        x = x + 1
        
    #### usando recursividade #####
    
    def funcao_conta_10(numero):
    	if numero >= 10:
    		return
        print(numero)
        funcao_conta_10(numero+1)
    
    funcao_conta_10(0)

     

     

  11. calma, é melhor vc quebrar em partes, vc precisa pensar num passo a passo, num algoritmo. O problema que você está tendo não é de programação, é de lógica/algoritmo.

    Vamos fazer pequenos algoritmos e ir evoluindo ele.

    Bom, vamos pensar assim. Você tem o min e tem o max. Alí vc ja trata, ta perfeito, temos o min e o max, o min é menor que o max e tudo ok.

     

    Agora, vc tem que iterar e printar todos os numeros entre o min e o max, incluindo eles mesmo.
    Agora que vc conseguiu iterar e pegar todos os numeros, dentro dessa iteração, cria outra iteração que pega todos os numeros entre 1 e o numero ta iteração atual. Então se o min é 10 e o max é 15, na primeira iteração, o que pegamos é o 10, e então iteramos pegando todos os numeros de 1 até 10.
    Certo, agora, nós temos todos os dividendos e todos os divisores.
    a partir dai é só começar a testar a divisão, e caso ela não aconteça, a gente pega o numero e printa ele

  12. kkkkk, certo

    agora a sua linha da variável calculo está ligeiramente errada. Antes de mais nada, ela deve estar dentro do while. Além disso,  a variável calculo em si não precisa existir.  Se você trocar a variável calculo pela variável resultado nos dois lugares em que ela foi escrita, ai então fica correto.

    Você precisar aprender a fazer o que chamamos de "teste de mesa". Basicamente é executar o programa linha a linha no papel, ou na cabeça, pra você entender o que ele está fazendo.

    Pense que a entrada dos dados via ser [5,2,6,-1]

    Resultado vale 0
    Entra no laço
    numero recebe 5
    numero é != de -1, logo não entra no if
    resultado recebe ele mesmo (0) * 10 + numero (5), ficando como resultado = 5
    repete loop*
    numero é 2
    numero nao é -1, nao entra no if
    resultado recebe ele mesmo (5 agora) *10 + 2, ficando resultado = 5*10+2,ou seja 50+2, ou seja 52 (olha só!)
    repete loop*
    numero é 6
    numero não é -1, nao entra no if
    resultado é 52*10+6 -> 520+6 -> 526
    repete loop*
    numero é -1
    numero é -1 !!! entra no if
    if interrompe o loop
    resultado, agora fora do loop, tem alor 526
    printa resultado!

  13. o problema ta na lógica.

    O que você montou basicamente encontra os números PARES, pois vc verifica se ele tem uma divisão inteiro por 2.

    Os numeros primos, nenhum numero deve conseguir dividir ele, exceto o 1 e ele mesmo.

    Basicamente vai ser um while com um while dentro. O Primeiro while vc já fez que é pra iterar sobre os numeros entre o min e o max.

    O segundo while vai ser pra tentar dividir todos os numeros entre 1 e o próprio numero (no caso o proóprio número é o número do while anterior, que você está chamando de count). Vamos chamar o numero do segundo while de divisor. Numa conta de dividir, temos o dividendo, dessa forma você tem os numeros para tentar dividir

    image.png

    vamos supor que o min seja 20 e o max seja 30

    você vai tentar dividir o 20 por todos os números anteriores a ele até o 2. Se algum desses números conseguir dividir de forma inteira, ele é primo. No caso do 20, sabemos que ele é divisível por 2, logo já podemos interromper o while do divisor e pular para o próximo dividendo, que é 21. 21 não é divisível por 2, então o while interno vai dar pelo menos "1 volta". Na segunda volta, o nosso divisor vale 3, e 21 é divido por 3, pode interromper e passar pro proximo dividendo. 22 é par, logo sabemos que também não é primo, o que finalmente nos leva pro 23.

    No 23, nenhum numero que vai de 2 até 22 é consegue dividir ele, ou seja, o while do divisor vai iterar até o fim e não vai conseguir encontra um divisor que divida esse numero, e isso o caracteriza como primo! só printar!

     

    Essa é uma lógica "simples" que vc consegue esse resultado. O Problema é que a complexidade é muito alta (O²) o que torna o algoritmo extremamente lento, mas é uma solução válida se o problema não exige uma grande de complexidade máxima (o que provavelmente não exige).

     

     

    da uma digerida e uma pensada nisso 😅

  14. oi!

    uma forma mais facil de lidar com isso é salvar numa tabela de banco de dados. Um simples left join excludente resolve o problema. Existe a possibilidade de fazer isso?

    Se não pode usar banco de dados, uma forma é carregar os CSVs em um dataframe, que é uma estrutura de dados que a lib pandas fornece. Ela é como uma tabela de banco de dados, e então vc consegue fazer a mesma coisa no código python.

    você até pode trabalhar isso sem pandas, mas como eu sou acostumado a usar ela, acho mais pratico

     

     

    fiz um exemplo simples onde eu simulei uma lista com 3 nomes e outra com 1 nome
     

    image.png

×
×
  • Create New...