[PHYTON] Ajuda a iniciante :D

B

| Blasted |

Portugal@Home Member
Olá a todos!

Estou a iniciar-me no mundo de phyton. Há algum tempo atrás andei, também por aqui, a pesquisar sobre com que linguagem começar e acabei por começar com Phyton pois pareceu-me a mais adequada.

Bem, estou a ler um livro (que por sinal até estou a achar muito bom) que com o avançar da matéria vai incluindo sempre exercicios para o 'aluno' resolver.

Um deles é este:
Python provides a built-in function called len that returns the length of
a string, so the value of len('allen') is 5.
Write a function named right justify that takes a string named s as a parameter and
that prints the string with enough leading spaces so that the last letter of the string is in
column 70 of the display.
Clicar para expandir...
Tentei resolver o exercicio e fiz este código:

def right_justify(arg):
. len('arg') = 70
. print arg


right_justify('qualquer_coisa')
Clicar para expandir...
Ao tentar correr este código dá-me erro e como novato que sou ainda não estou bem na parte onde percebo exactamente onde errei e percebo o que o interpretador me diz :D
Portanto, o que está mal?
 
Olá,

Não podes resolver esse problema desse modo.

A instrução:
Código: 
len('arg') = 70
é ilegal.

A ideia é transformares a palavra que rebeste, com tamanho n, numa palavra com tamanho 70; dizem-te para utilizar espaços em branco para fazeres "crescer" a palavra; também te pedem que o último caracter, da palavra que recebeste, fique na coluna 70.

Por exemplo:
Código: 
$ ./right_justify.py
Palavra original: [qualquer_coisa]
Resultado: [                                                        qualquer_coisa]
$
Cumps,
JP

Uma dica: Irás precisar de 70-#<tamanho da palavra> espaços em branco...
 
Tens aí um erro.
Código: 
    y = 70 - len('arg')
A arg que queres passar é uma variável e não uma string. Quando metes algum texto entre plicas ('), estás a indicar que o que envias é uma string (texto), independentemente do que estiver lá ser, por acaso, o nome de uma váriável, uma palavra reservada, o que for.
No teu código actual irias sempre receber 67 (70-len('arg'), ou seja, 70-3) espaços, e depois a palavra passada em arg.

Tenta resolver, é simples ;)
 
Código: 
def right_justify(arg):

    y = 70 - len(arg)
    x = ' '     
    print ((x*y)+arg)

right_justify('aaa')

É só tirar os ('), certo?
Assim indico que o len que quero medir é o arg da funçao e nao o 'arg' como string.
Correcto?
 
Bem, continuo com a minha aprendizagem!
:D

Agora surgiu-me o seguinte exercicio:

Código: 
• Write a function that draws a grid like the following:
+ - - - - + - - - - +
|         |         |
|         |         |
|         |         |
|         |         |
+ - - - - + - - - - +
|         |         |
|         |         |
|         |         |
|         |         |
+ - - - - + - - - - +
Já fiz uma função que desenha a grelha e não tive problemas.
O problema está no seguinte(alinea seguinte do exercicio): a função tem que ser "adaptável", isto é eu digo x colunas e y linhas e ela desenha uma grelha semelhante a esta mas com x colunas e y linhas.
Estou um bocado confuso sobre como "pegar" para fazer uma função assim.
Podiam-me dar umas dicas?

P.S: Não quero o código. Quero apenas uma 'direcção' a seguir. Gosto de chegar ás cenas por mim.

abraço,
 
Última edição:
Primeiro, arranja forma de receberes esses valores na função.

Depois, é seguires a primeiro parte da ideia dos espaços. Tens de fazer uns poucos cálculos simples (com as variáveis que recebes) para saber quantas peças tens de desenhar.

Acho que não falei demais :D

Boa sorte! ;)
 
shello disse:
Primeiro, arranja forma de receberes esses valores na função.

Depois, é seguires a primeiro parte da ideia dos espaços. Tens de fazer uns poucos cálculos simples (com as variáveis que recebes) para saber quantas peças tens de desenhar.

Acho que não falei demais :D

Boa sorte! ;)
Clicar para expandir...

Acho que até falaste de menos :D

Bem, por partes:
Código: 
def grelha(x,y):  # x=linhas y=colunas
Com isto consigo saber quantas colunas e linhas o utilizador quer. Certo?

A partir daqui continuo um bocadinho entalado.. Acho que o que me está a complicar o raciocínio (porque até acho que isto não deve ser mt complicado) é o não encontrar um "padrão" na grelha para depois a construir. Não sei se me fiz entender :S
 
Exacto, esse é o cabeçalho.
Precisas de ver agora de ver como vais repetir isso, e de saber qual é o padrão.

Não faço ideia se podes usar ciclos de repetição. Vou assumir que ainda não chegaste aí.

Uma primeira hipótese:
Guardar duas variáveis com os dois tipos diferentes de linha.
Existem duas linhas nessa grelha. O primeiro tipo, a bordadura (no topo, no centro e no fundo). O segundo tipo, as outras todas. Logo, irias gerar estas duas variáveis.
Agora a forma de pensar é igual para caracteres na linha ou para linhas em si (vou chamar elemento): Tens um primeiro elemento que é diferente (dentro da linha, é um +, na grelha é uma linha de bordadura); depois uma série deles iguais, voltas a ter um elemento diferente (centro), outra série de iguais e acaba com um diferente. Existem três diferentes a subtrair ao número total. Como tem de estar divido em igual, divides o resultado da diferença por dois e tens a quantidade de elementos em cada uma daquelas séries.

Outra hipótese: Parecida à de cima, só que não usas variáveis e geras tudo a altura.

São as formas mais simples, baseadas no que eu consigo entender que estão a pedir que apliques.
 
Bem shello, em primeiro lugar obrigado pela ajuda e pela paciência! ;)

Um pouco contra os meus principios, mas também para tentar "engatar" em como se faz isto, podes me deixar aí algum código?
O cabeçalho já tá, agora o teu raciocínio para o padrão descrito em código.
Ok? (Isto se não te importares)

abraço,

EDIT: Estou mesmo a tentar chegar lá sozinho.
Até agora fiz isto:

Código: 
def grelha(x,y):   # x = linhas y = colunas
    a = '+ - - - - '
    b = '+'
    def borda():
        print (y * a) + b
    c = '|         '
    d = '|'
    def linha():
        def linha2():
            print (y * c) + d
        linha2()
    def um_quatro(x,y):
        x()
        y()
        y()
        y()
        y()
    
    um_quatro(borda, linha)
    
    
grelha(3,5)
Desta forma consigo personalizar quantas colunas quero.
Falta-me as linhas!
 
Última edição:
Decidi fazer um novo post para não ficar demasiado confuso.
Neste momento a minha função é esta:

Código: 
def grelha(x,y):   # x = linhas y = colunas
    a = '+ - - - - '
    b = '+'
    def borda():
        print (y * a) + b
    c = '|         '
    d = '|'
    def linha():
        def linha2():
            print (y * c) + d
        linha2()
    def um_quatro(e,f):
        e()
        f()
        f()
        f()
        f()
        
    def linhas():
        um_quatro(borda, linha)
        
    linhas()


grelha(3,5)

A única coisa que penso que me falta é arranjar maneira de multiplicar a ultima função que aqui tenho "def linhas():" pelo numero de linhas que quero, fazendo-as aparecer sempre "verticalmente" e acresecentar depois um "borda()" no fim para fechar a grelha.
 
Acho que é difícil explicar-te sem te dar o código. É mais uma questão de análise de problema do que outra coisa, viste que os + - - - se repetem sempre que o numero da linha é multiplo de 6, logo verificando essa instrução sabes que tipo de linha deves fazer print. Para o padrão em x, basta definires um elemento inicial (+ ou |) e repetir uma seq multiplicada x vezes. Espero que o código, feito à pressa, seja claro :/

Código: 
def grelha(x,y):
    
    linhas = 6 * y
    
    multiplos = []
    
    for i in range(1,linhas):
        
        multiplo = 6 * i
        
        if multiplo > linhas:
            break
        
        multiplos.append(multiplo)
    
    for i in range(0,linhas+1):
        
        if i in multiplos or i==0:
            print '+' + ' - - - - +' * x
        else:
            print '|' + '         |' * x
 
Última edição:
Ficaria assim:

Código: 
# -*- coding: utf-8 -*-

def grelha(x,y):  # x=linhas y=colunas
    # Definir os dois tipos de linhas
    tmp = ((y-3)/2)                    #Nuúmero de elementos entre as junções/bordaduras
    special = '+' + tmp*'-' + '+' + tmp*'-' + '+' + '\n'
    normal  = '|' + tmp*' ' + '|' + tmp*' ' + '|' + '\n'
    
    # Criar as linhas da grelha
    tmp = ((x-3)/2)                    #Número de linhas entre as especiais
    print 2*(special + (tmp*normal) ) + special
(A primeira linha é por causa dos comentários com acentos)

Assumi, mais uma vez, que não sabes ainda usar ciclos de repetição como o firedrops pôs. Não são realmente necessários, mas era como eu faria intuitivamente :)
 
Última edição:
shello disse:
Ficaria assim:

Código: 
# -*- coding: utf-8 -*-

def grelha(x,y):  # x=linhas y=colunas
    # Definir os dois tipos de linhas
    tmp = ((y-3)/2)                    #Nuúmero de elementos entre as junções/bordaduras
    special = '+' + tmp*'-' + '+' + tmp*'-' + '+' + '\n'
    normal  = '|' + tmp*' ' + '|' + tmp*' ' + '|' + '\n'
    
    # Criar as linhas da grelha
    tmp = ((x-3)/2)                    #Número de linhas entre as especiais
    print 2*(special + (tmp*normal) ) + special
(A primeira linha é por causa dos comentários com acentos)

Assumi, mais uma vez, que não sabes ainda usar ciclos de repetição como o firedrops pôs. Não são realmente necessários, mas era como eu faria intuitivamente :)
Clicar para expandir...

firedrops disse:
Acho que é difícil explicar-te sem te dar o código. É mais uma questão de análise de problema do que outra coisa, viste que os + - - - se repetem sempre que o numero da linha é multiplo de 6, logo verificando essa instrução sabes que tipo de linha deves fazer print. Para o padrão em x, basta definires um elemento inicial (+ ou |) e repetir uma seq multiplicada x vezes. Espero que o código, feito à pressa, seja claro :/

Código: 
def grelha(x,y,tamanho):
    
    linhas = tamanho * y
    
    multiplos_y = []
    
    for i in range(1,linhas):
        
        multiplo = tamanho*i
        
        if multiplo > linhas:
            break
        
        multiplos_y.append(multiplo)
    
    for i in range(0,linhas+1):
        
        if i in multiplos_y or i == 0:
            print '+' + ' - - - - +' * x
        else:
            print '|' + '         |' * x
Clicar para expandir...

Mais uma vez obrigado. Mas tal como o shello disse, não sei usar ciclos de repetição.
Percebi agora o vosso método e realmente é o mais lógico. Mas já agora pegando na minha função:
Código: 
def grelha(x,y):   # x = linhas y = colunas
    a = '+ - - - - '
    b = '+'
    def borda():
        print (y * a) + b
    c = '|         '
    d = '|'
    def linha():
        def linha2():
            print (y * c) + d
        linha2()
    def um_quatro(e,f):
        e()
        f()
        f()
        f()
        f()
        
    def linhas():
        um_quatro(borda, linha)
A única coisa que penso faltar é mesmo conseguir multiplicar verticalmente a função linhas pelo nr de linhas que quero. E acrescentar depois um borda() pra fechar a grelha.
É capaz de estar um pouco confuso, mas acho que também funcionava.
Como posso fazer isso? Dá para fazer?

brw, shello esse teu código funciona? Pelo menos aqui no meu interpretador não está completo. Deves ter esquecido alguma coisa.
 
A função do Shello não está desenhada para o número de linhas/colunas mas para o número de caracteres por linha e coluna. Tenta valores mais elevados que já obtens o que desejas (ex. grelha(20,30) )

Em relação à tua função, acho que estás a obtar por uma abordagem um pouco demasiado complexa. Pena ainda não saberes ciclos de repetição (embora não sejam nada difíceis). Eu reeditei a minha função porque vi que tu consideravas um tamanho fixo para o quadrado que eu não estava a considerar na minha primeira função (daí ter posto um argumento para o tamanho da grelha).
 
Inicie sessão ou registe-se para poder participar.
Back
Topo