O que é Python?
Python é uma linguagem de programação escrita em C, a sua implementação original também é conhecida como CPython. Python tem alguns aspectos que a tornam especial:
- É uma linguagem interpretada. Não necessita de compilação, o fonte é executado direto pelo interpretador.
- Dinamicamente tipada. (Não necessita de declaração de variável).
- Não há delimitadores de bloco ( { } ), isto é feito apenas pela Indentação.
- Tipagem forte. Verifica se a operação é válida e não faz correção automática entre os tipos incompatíveis.
- Trabalha com operadores de alto nível: string, lista, tupla, dicionário, arquivo, classes
- É orientada a objetos: Afinal, tudo em Python é um objeto.
Por que Python?
Bom, eu também me fazia esta pergunta antes de ter qualquer contato com a linguagem. Agora, vejo o porquê, mas fica aqui alguns tópicos encontrados em um site:
Dado que existe uma grande diversidade de linguagens diferentes, por que aprender Python é interessante ou mesmo importante? Na minha opinião, a linguagem combina um conjunto único de vantagens:
? Os conceitos fundamentais da linguagem são simples de entender.
? A sintaxe da linguagem é clara e fácil de aprender; o código produzido é normalmente curto e legível.
? Os tipos pré-definidos incluídos em Python são poderosos, e ainda assim simples de usar.
? A linguagem possui um interpretador de comandos interativo que permite aprender e testar rapidamente trechos de código.
? Python ´e expressivo, com abstrações de alto nível. Na grande maioria dos casos, um programa em Python será muito mais curto que seu correspondente escrito em outra linguagem. Isto também faz com o ciclo de desenvolvimento seja rápido e apresente potencial de defeitos reduzido – menos código, menos oportunidade para errar.
? Existe suporte para uma diversidade grande de bibliotecas externas. Ou seja, pode-se fazer em Python qualquer tipo de programa, mesmo que utilize gráficos, funções matemáticas complexas, ou uma determinada base de dados SQL.
? É possível escrever extensões a Python em C e C++ quando é necessário desempenho máximo, ou quando for desejável fazer interface com alguma ferramenta que possua biblioteca apenas nestas linguagens.
? Python permite que o programa execute inalterado em múltiplas plataformas; em outras palavras, a sua aplicação feita para Linux normalmente funcionará sem problemas em Windows e em outros sistemas onde existir um interpretador Python.
? Python é pouco punitivo: em geral, “tudo pode” e há poucas restrições arbitrárias. Esta propriedade acaba por tornar prazeroso o aprendizado e uso da linguagem.
? Python é livre: além do interpretador ser distribuído como software livre (e portanto, gratuitamente), pode ser usado para criar qualquer tipo de software — proprietário ou livre. O projeto e implementação da linguagem é discutido aberta e diariamente em uma lista de correio eletrônico, e qualquer um é bem-vindo para propor alterações por meio de um processo simples e pouco burocrático.
Bom, vamos ao que interessa, Como funciona o Python!
Sintaxe:
NÃO NECESSITA DE
; haha
Comentários são feitos com o marcador (#), e comentário em bloco por (""").
Comando Print:
a = 21
print "Minha idade é", a
print "Minha idade é %d !!" %a
print 'Minha idade é', a, "!!"
>>>
Minha idade é 21
Minha idade é 21 !!
Minha idade é 21 !!
No caso de formatação no print, pode ser utilizado os mesmos tipos de C, como o (%.2f) para float, porém todo o %(marcador, ex: %d, %f,...) que houver no print tem de existir um % para acesso a variável.
Por isso no segundo exemplo acima é necessário o %a.
Tipagem Dinâmica:
Python não define tipos para variável, como int, float, String, double, complex, bool mas trabalha com todos eles.
a = 1
type(a) #função que retorna o tipo associado a uma variável
>>>
print a
>>>
1
a = "teste"
print a
>>>
teste
Nota que o mesmo a que foi primeiramente atribuído um int, em seguida foi atribuído uma String?
Mas como isso é possível? Em C e Java isto é impensável, mas como Python é tipado dinamicamente, a variável assume o tipo de acordo com seu valor.
Exemplo de criação de variáveis
a = 1 # valor inteiro
preco = 10.99 # valor ponto flutuante, ou float.
t = True # valor booleano
i = 4+3j # valor complexo / Só pelo nome ainda nem sequer mandei um print pra testar como funciona, hehe
a = 'Arena'
b = ' > '
c = ' Beira Rio'
print a + b + c
>>>
Arena > Beira Rio
Estamos trabalhando com String certo? Como podemos saber quais métodos estão disponíveis para este tipo de dado e que o Python nos prove?
Com a função dir(),ela analisa a nossa variável e nos retorna os métodos do tipo pertinente.
dir(a)
>>>
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
Métodos reservados são os que começam com __, por exemplo o método '__add__', que é chamado toda vez que usamos o (+).
Atribuindo caracteres da string a variáveis:
a, b, c, d = "TADS"
print a
print b
print c
print d
>>>
T
A
D
S
Multiplicação de uma String, isso é impensável em Java mas em Python ele realmente multiplica, mas o valor desta variável:
var = "TADS "
print var*5
>>>
TADS TADS TADS TADS TADS
Atribuição de variável;
O Python por ser criado em cima do C, carrega suas características.
Se fizermos duas variáveis, e dissermos que a segunda é igual a primeira, não temos duas alocações de memória, e sim dois apontamentos para o mesmo endereço de memória.
Descobrimos a posição na memória da variável através da função id().
A função retorna a identidade do objeto que é a garantia de ser único e constante para este objeto durante sua vida. Dois objetos com vida no programa ou execução não sobrepostos podem ter o mesmo id().
Ex:
a = 100
b = a
c = a+1
print id(a)
>>>
1533140
print id(b)
>>>
1533140
print c
1>>>
11533128
Nota que o id da variável a e b tem o mesmo valor, pois apontam para a mesma posição de memória. (Ahh, como é bom não lidar com ponteiros! :D)
Fortemente Tipada:
Uma vez atribuída a uma variável um valor inteiro, ela não pode ser somada com uma variável com uma String. Em JavaScript isto até funciona, pois a linguagem é fracamente tipada e então faz conversão automática mas em Python não.
Ex:
a = 'Grêmio fundado em '
b = 1903
print a+b
>>>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Se quisermos uma string concatenada com estas duas variáveis devemos fazer uma conversão com cast.
No caso de inteiro para String é usado str().
print a + str(b)
>>>
Grêmio fundado em 1903
Se fosse uma soma e tivéssemos um valor em string, seria usado int().
Uma coisa curiosa que o Python oferece é a troca de valor entre variáveis.
Vejam só.
Sendo a = 10 e b = 20 faça a troca de valores entre a e b.
Obs: Não vale fazer isso:
print 'a = %d \nb = %d' %(b, a)
Você que está lendo instintivamente pensou, vou fazer uma variável auxiliar!
c = a
a = b
b = c
print a, b
>>>
20 10
Funciona? Sim! É a maneira correta e eu vou aceitar isso? NÃO ("- Vocês já sabem quem eu imitei! haha")
Em Python a simples inversão de valores entre variáveis se dá desta forma:
a, b = b, a;
print 'a = %d \nb = %d' %(a, b)
>>>
a = 20
b = 10
Fácil, não?
Entrada de Dados:
.
Ok, trabalhar com entrada de dados em Python é bem infinitamente mais fácil que Java e é mais fácil que C.
Temos que chamar o método ( input(texto_de_entrada_no_console))
Vamos ler do teclado um texto qualquer:
txt = input('Entre com alguma coisa')
print txt
>>>
o_que_digitamos
Se quisermos tratar esta entrada para um tipo especifico é só adicionar o cast de conversão:
Ex:
idade = int(input('Entre com sua idade')
print 'Tu nasceu em %d' %(2014 - idade)
>>>
1993 #só p testar, pois se tu ainda não fez aniversário em 2014, ele vai te dar um ano de nascimento a mais! :/
Lembre-se. Python é fortemente indentado. Se tiver erro de indentação, ele nem executa.
print a
print b
^
Erro de indentação
Blocos de Código:
Todo bloco de código são delimitados pelo uso da indentação, e sempre a linha anterior ao bloco deve terminar com (:).
Ex:
#imprime impares
for i in range(0,100):
if i % 2:
print i
Controle de Fluxo:
Conjunto de instruções com um condicional pelo menos.
if :
elif :
else:
Ex:
temp = 10
if temp < 0:
print 'Congelando...'
elif 0 <= temp <= 20:
print "Frio"
elif 20 <= temp <= 30:
print 'De Boa'
else:
print "Muito Quente"
>>>
Frio
Percebam que independe do print se usarmos (') ou (").
Laços:
For:
for in :
continue
break
else:
A clausula break interrompe o laço e continue passa para a próxima iteração. O código dentro do else é executado ao final do laço, a não ser que o laço tenha sido interrompido por break.
Exemplo:
# Soma de 0 a 99
s = 0
for x in range(1, 100):
s = s + x
print s
>>>
4950
A função range(m, n, p),é muito útil em laços, pois retorna uma lista de inteiros, começando em m e menores que n, em passos de comprimento p, que podem ser usados como sequência para o laço.
Tipos de dados de Alto Nível:
Além de tipos básicos como (int, float, boolean,..) Python possuem determinados tipos que merecem atenção:
String:
String é uma sequência imutável que armazena uma sequência de caracteres. Pode ser tanto delimitada com aspas duplas quanto com aspas simples. Se for delimitada com aspas simples, podemos usar aspas duplas como parte integrante da string.
a = "Exemplo de String"
b = 'Exemplo com "Aspas Duplas"'
#Se quisermos criar uma string com múltiplos caracteres o Python nos prove um delimitador aspas triplas, (""")
bairrista = """...
Mostremos valor constância
Nesta ímpia e injusta guerra
Sirvam nossas façanhas
De modelo a toda Terra
..."""
print bairrista
>>>
...
Mostremos valor constância
Nesta ímpia e injusta guerra
Sirvam nossas façanhas
De modelo a toda Terra
...
E também, como todos já estiveram em ED1 ou AAP sabem, como toda sequência a String pode ser indexada dividida ou acessada usando colchetes
teste = "Instituto Federal"
print teste[0]
>>>
I
print teste[16]
>>>
l
print teste[-1]
>>>
l
print teste[:11]
>>>
Instituto F
print teste[-6:-1]
>>>
edera
Percebam que como o Python trabalha com String e Lista como se fosse lista Circular a posição da string -1 e a 16 que é a última, são a mesma letra!
Com isso, é possível trabalhar de inúmeras formas com a string, no caso acima foi pedido para mostrar de moonwalker(traz pra frente) da Posição -6 até a -1 o que continha a variável.
Listas:
Como uma sequência de valores, vetor em outras linguagem. Os dados são acessados por um índice numérico iniciado em 0.
A lista do Python pode armazenar qualquer tipo de valor, são mutáveis, podendo ser alteradas a qualquer momento.
Ex:
lista = ["t", "A", "d", "S", 9, 2, 2014, "Dalhe Grêmio", "Saldo:", 0.50]
print lista[0]
>>>
t
print lista[7]
>>>
Dalhe Grêmio
print lista[0],lista[1], lista[2], lista[3]
>>>
t A d S
lista.append("teta")
print lista[10]
>>>
teta
Percebam que como é uma lista, alguns métodos já são pré-existentes em Python.
Podemos percorrer a lista inteira com um Iterador sobre ela.
for item in lista:
print item
>>>
t
A
d
S
9
2
2014
Dalhe Grêmio
Saldo:
0.5
teta
Listas podem incluir outras listas internamente.
Algumas outras Operações com lista são:
# Incluindo
lista.append('Robin')
# Removendo
lista.remove('teta')
# Ordena a lista
lista.sort()
# Inverte a lista
lista.reverse()
# Imprime numerado
for i, item in enumerate(lista):
print i + 1, '=>', item
A lista pode ser acessada o seu último elemento sem saber a sua posição, somente é necessário indicar que é o elemento anterior ao primeiro, como se fosse uma lista circular.
# Trocando o último elemento
lista[-1] = 'Batman'
A lista possui o método pop() que facilita a implementação de filas e pilhas:
# A lista vazia é avaliada como falsa
while lista:
# Em filas, o primeiro item é o primeiro a sair
# pop(0) remove e retorna o primeiro item
print 'Saiu', lista.pop(0), ', faltam', len(lista)
# Mais itens na lista
lista += ["AAP", 'Ed1', 'Ed2']
As operações de ordenação sort() e inversão reverse()são realizadas na própria lista, sendo assim, não geram novas listas.
Tuplas:
As Tuplas também são sequencias de elementos arbitrários, se comportam como as listas mas tem uma exceção importante. São imutáveis. Uma vez criadas não podem ser alteradas.
Sintaxe:
tupla = (a, b, ..., z)
Os parênteses são opcionais.
Particularidade: tupla com apenas um elemento é representada como:
t1 = (a,)
Os elementos de uma tupla podem ser referenciados da mesma forma que os elementos de uma lista:
primeiro_elemento = tupla[0]
Listas podem ser convertidas em Tuplas:
tupla = tuple(lista)
E Tuplas podem ser convertidas em listas:
lista = list(tupla)
Embora a tupla possa conter elementos mutáveis, esses elementos não podem sofrer atribuição, pois isto modificaria a referência ao objeto.
Exemplo:
tupla = ([1, 2], 4)
tupla[0].append(3)
print tupla
>>>
([1, 2, 3], 4)
tupla[0].append("TADS")
print tupla
>>>
([1, 2, 3, 'TADS'], 4)
As Tuplas são mais eficientes do que as listas convencionais, pois consomem menos recursos computacionais (memória), por serem estruturas mais simples, tal como as String imutáveis em relação às String mutáveis.
Outros tipos de sequências
O Python provê entre os builtins também:
set: sequência mutável unívoca (sem repetições) não ordenada.
frozenset: sequência imutável unívoca não ordenada.
Os dois tipos implementam operações de conjuntos, tais como: união, interseção e diferença.
OBS: Quando uma lista é convertida para set, as repetições são descartadas.
Dicionário:
Os dicionários são sequencias que podem utilizar índices de tipos variados, basta que estes índices sejam imutáveis (números, tuplas e strings,..). Dicionários são conhecidos em outras linguagens como arrays associativos ou hashes.
Um dicionário é uma lista de associações compostas por uma chave única e estruturas correspondentes.
Dicionários são mutáveis, tais como as listas.
Estrutura Dicionário:
[[FOTO Dicionário]]
autor = {"nome" : "Marcos", "sobrenome" : "Scholl", "idade": 21}
print autor["nome"]
>>>
Marcos
print autor["sobrenome"]
>>>
Scholl
print autor["idade"]
>>>
21
O dicionário do Python não fornece garantia de que as chaves estarão ordenadas.
Exemplo de dicionário:
dic = {'nome': ['Angus Young', 'Malcolm Young', 'Phil Rudd', 'Cliff Williams', 'Brian Johnson'], 'banda': 'AC/DC'}
#Acessando elementos:
print dic['nome']
>>>
['Angus Young', 'Malcolm Young', 'Phil Rudd', 'Cliff Williams', 'Brian Johnson']
#Adicionando elementos:
dic['album'] = 'Back in Black'
Apagando um elemento do dicionário:
del dic['album']
Obtendo os itens, chaves e valores:
itens = dic.items()
chaves = dic.keys()
valores = dic.values()
dic.keys()
>>>
['banda', 'nome']
Nota que ele Ordenou as chaves.
dic.values()
>>>
['AC/DC', ['Angus Young', 'Malcolm Young', 'Phil Rudd', 'Cliff Williams', 'Brian Johnson']]
Matriz Esparsa:
Bom, matriz creio que todos já conhecem o seu funcionamento, nada mais é que um vetor de duas dimensões. Possui a característica de Linhas e Colunas.
Agora, uma matriz esparsa, sabes o que é?
Segundo uma definição da Wikipedia : http://pt.wikipedia.org/wiki/Matriz_esparsa
Uma matriz é dita esparsa quando possui uma grande quantidade de elementos que valem zero (ou não presentes, ou não necessários).
A matriz esparsa é implementada através de um conjunto de listas ligadas que apontam para elementos diferentes de zero. De forma que os elementos que possuem valor zero não são armazenados.
Ou seja, em breve definição Matriz esparsa é uma estrutura que só armazena os valores que existem na matriz.
Uma boa alternativa é usarmos um Dicionário. Para as chaves, nós podemos usar Tuplas que contêm os números da linha e a coluna.
No caso, achei um bom exemplo de matriz esparsa em Python utilizando Dicionário e Tuplas.
Cada tupla representa uma posição na matriz
Matriz esparsa implementada com dicionário
dim = 6, 12 #Define as características da matriz
mat = {} #define a matriz
mat[3, 7] = 3 # Instancia valores em pontos aleatórios da matriz
mat[4, 6] = 5
mat[6, 3] = 7
mat[5, 4] = 6
mat[2, 9] = 4
mat[1, 0] = 9
for lin in range(dim[0]):
for col in range(dim[1]):
# Método get(chave, valor) retorna o valor da chave no dicionário ou se a chave não existir, retorna o segundo argumento
print mat.get((lin, col), 0),
print
Saída:
0 0 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 4 0 0
0 0 0 0 0 0 0 3 0 0 0 0
0 0 0 0 0 0 5 0 0 0 0 0
0 0 0 0 6 0 0 0 0 0 0 0
Nota que muitos valores nesta matriz são dispensáveis, nesta matriz somente nos importa 6 valores. E estes 6 valores são a quem corresponde a matriz esparsa!!
Exemplo de Criação da Matriz Esparsa, através de uma String!
# Matriz em forma de string
matriz = '''
0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 1 0 1 1 1 1 0
0 1 1 0 1 1 0 1 0 0 0 0
0 1 0 1 0 1 0 1 1 1 1 0
0 1 0 0 0 1 0 0 0 0 1 0
0 1 0 0 0 1 0 1 1 1 1 0'''
mat = {}
# Quebra a matriz em linhas
for lin, linha in enumerate(matriz.splitlines()):
# Quebra a linha em colunas
for col, coluna in enumerate(linha.split()):
coluna = int(coluna)
# Coloca a coluna no resultado,
# se for diferente de zero
if coluna:
mat[lin, col] = coluna
print mat
# Soma um nas dimensões pois a contagem começa em zero
print 'Tamanho da matriz completa:', (lin + 1) * (col + 1)
print 'Tamanho da matriz esparsa:', len(mat)
>>>
{(4, 7): 1, (4, 8): 1, (2, 8): 1, (6, 9): 1, (2, 1): 1, (3, 7): 1, (5, 1): 1, (2, 5): 1, (4, 9): 1, (5, 5): 1, (2, 9): 1, (6, 10): 1, (4, 1): 1, (4, 10): 1, (3, 2): 1, (4, 5): 1, (2, 10): 1, (6, 7): 1, (6, 5): 1, (3, 5): 1, (2, 7): 1, (5, 10): 1, (6, 8): 1, (6, 1): 1, (3, 1): 1, (4, 3): 1, (3, 4): 1}
Tamanho da matriz completa: 84
Tamanho da matriz esparsa: 27
Percebam que temos desenhado na matriz esparsa um MS, Marcos Scholl! :D
A matriz esparsa é todos estes pontos que possuem 1.
Matrizes esparsas têm aplicações em problemas de engenharia, física (por exemplo, o método das malhas para resolução de circuitos elétricos ou sistemas de equações lineares). Também têm aplicação em computação: armazenamento de dados (e.g., planilhas eletrônicas)
Funções:
Funções são blocas de código com um nome que podem receber parâmetros pré-determinados.
É a mesma definição de método de Java. Elas podem ou não retornar objetos.
Sintaxe:
def nome_funcao(parametro1, parametro2):
return valor
Ex:
semestre = {'3º': ['AAP', 'ED1', 'Redes', 'RAD1'], '4º': ['ED2','ES2','SI','ED2']}
def imprime_semestre(self):
for materias in self.items():
print materias
imprime_semestre(semestre)
>>>
('3º', ['AAP', 'ED1', 'Redes', 'RAD1'])
('4º', ['ED2', 'ES2', 'SI', 'ED2'])
Percebam duas coisas, a primeira é o funcionamento da função que não tem retorno, se tivesse retorno ela só funcionária se passado à uma variável auxiliar.
Outra coisa é o funcionamento do argumento da função.
Funções e Classes em Python trabalham com o self que é definido sempre para o primeiro argumento que se tem passado para a ela.
Como somente passamos o dicionário semestre para a função, dentro dela ele pode ser referenciado como self.
Exemplo com retorno:
def calcula_imposto_federal(vlrProd):
imposto = 999 #%
return vlrProd * imposto
#Produto custa R$ 10.00
vlrComImposto = calcula_imposto_federal(10)
print 'R$', vlrComImposto
>>>
R$ 9990
Outra coisa legal que Python tem é ARGUMENTO PADRÃO, um Argumento que se não for passado, assume um valor declarado na função.
Ex:
def aplica_multa(valor, taxa=0.1):
return valor + valor * taxa
print aplica_multa(10)
>>>
11.0
print aplica_multa(10, 0.5)
>>>
15.0
Interessante né?
Classes:
Como já dito antes, tudo em Python é um objeto, tipos, valores, classes, funções, métodos e instancia, todos possuem atributos e métodos associados.
E a estrutura fundamental para de criar novos objetos é obviamente a CLASSE.
Como vocês já sabem, uma classe tem um nome, um conjunto de atributos e seus métodos.
Sintaxe:
class calculadora:
a = 10
b = 20
def clacula_soma(vlr1,vlr2):
return vlr1 + vlr2
def clacula_multiplicacao(a,b):
return vlr1 * vlr2
def __init__(a, b)
print 'A soma é ', clacula_soma(a, b)
Quanto aos métodos, agora vemos um novo, __init__. Este é um método muito especial em Python pois ele na verdade é o método CONSTRUTOR, um método opcional que é executado quando esta classe for instanciada.
Ele é equivalente ao Main do Java.
Ex: Se você usar o Qt(biblioteca para interface, tipo o Swing ou JavaFX) montar a tua tela, pegar o código e quiser visualizar ele, tu vais ter que fazer o método __init__ no teu arquivo.py para dizer que vai instanciar um objeto com essa tela. E posteriormente usar o método .show().
Bom, já está bem extenso, isto que era pra ser "apenas" um post! :D
Trabalhando Com Python, Terminal interativo ou IDE:
Tem duas formas de trabalhar com a linguagem, a mais básica e para poucas aplicações que é o terminal interativo.
É a mesma coisa que codificar no terminal.
E a maneira profissional que é utilizando uma IDE para isto. Existem várias no mercado, mas eu recomendo a que eu utilizo, :D, Spyder. É completa, pode-se trabalhar com pacotes, intuitiva e simples!
https://code.google.com/p/spyderlib/
Todo arquivo "executável" de Python tem seu formato atribuído ao .py
Todos os códigos descritos aqui podem ser testados online mesmo, sem precisar instalar o Python em suas maquinas(Linux já vem na distribuição), o Snape indicou um interpretador Online: http://repl.it/languages/Python
Obs: Todos os Códigos que possuem
>>> Significa que a linha à seguir vem com uma resposta da execução, então na hora de passar para o interpretador remover o
>>> e apagar as linhas abaixo, pois elas não fazer parte do código e sim a resposta do console de execução.
Qualquer dúvida, sugestão, reclamação, voadora, ..., estou aberto a ouvir, afinal ainda estou aprendendo, assim como vocês! hehe
Erros podem ter escapado da minha percepção.
Dedico este post/artigo ao grande Milhouse que me incentivou a começo e ao Carlos Rocha que me apresentou a esta linguagem!
