Caminho do import

Quando importamos um módulo, como o interpretador Python sabe onde ele está?
Na verdade existe uma lista de locais de onde esses modulos são importados.Para vê-la, basta digitar da linha de comando:

>>> from sys import path
>>> path
['', '/usr/lib/python24.zip', '/usr/lib/python2.4', '/usr/lib/python2.4/plat-linux2', '/usr/lib/python2.4/lib-tk', '/usr/lib/python2.4/lib-dynload', '/usr/local/lib/python2.4/site-packages', '/usr/lib/python2.4/site-packages', '/usr/lib/python2.4/site-packages/HTMLgen', '/usr/lib/python2.4/site-packages/Numeric', '/usr/lib/python2.4/site-packages/PIL', '/usr/lib/python2.4/site-packages/cairo', '/usr/lib/python2.4/site-packages/gst-0.10', '/usr/lib/python2.4/site-packages/gtk-2.0', '/usr/lib/site-python']

E para adicionar um caminho, basta utliziar o método 'append' de lista. Assim podemos adicionar um local para o interpretador buscar os módulos que nós vizemos.

from 'modulo' import *

Para importar um modulo em Python, basta fazer:

import 'modulo'

isso não e nenhum misterio. Do mesmo jeito que para importar apenas um método ou uma função de um módulo é bem simples:

from 'modulo' import 'algo'

Mas você já deve ter visto o from 'modulo' import *.
Isso importa todu que tem no módulo. Mas ai você se pergunta: e por que não usar somente o import 'modulo' ?
Quando usamos somente o import, todas as funções e atributos desse módulo importado não pertencem ao namespace do nosso modulo, ou seja, caso importamos o módulo 'teste', por exemplo, caso queira me referir a uma função de 'teste' eu terei que fazer:

teste.nome_da_função

já se eu usar o from teste import *, todas as funções e métodos do modulo 'teste' importado serão variaveis locais do meu modulo. E não será mais preciso usar a sintaxe acima.

Um pouco mais de namespaces aqui.

Namespaces, locals() e globals()

Quando nós criamos uma variável, onde ela fica guardada exatamente? Isso vai depender de onde ela foi criada. Caso tenha sido dentro de uma função, ela só existirá para aquela função, será uma variável local, pertencendo a um "namespace" local, e quando essa função não for mais usada, a variavel desaparecerá.

Namespaces são onde ficam registradas as variáveis, e funcionam como um dicionário, onde as chaves são os nomes das variáveis, e os valores são os valores dessas variáveis. Existem três tipos de namespaces:

- Namespace local: como citado acima, se refere a uma função ou método de classe. As variáveis desse namespace só poderão ser acessadas de sua função ou método de classse onde ela pertence.

- Namespace global: é onde ficam todas as variáveis, funções, classes, módulos importados, do módulo corrente. Normalmente esse namespace dura até o fim do programa.

- Namespace embutido: esse é acessível de qualquer módulo, e contém funções e excessões embutidas. Ele é criado quando o interpretador python é aberto, e dura até ele ser fechado. As variaveis desse namespace ficam em um módulo, chamado __builtin__.

Quando, no meio do código, existe uma chamada a uma variável, o interpretador python segue uma sequencia de busca pra achar o valor dessa variável. Primeiro ele procura no namespace local, não achando, procura no namespace global, em seguida no namespace embutido. Caso exista uma função aninhada ou lambda dentro de outra, procura-se primeiro no namespace dessa função, depois no da função ascendente e so depois no global e embutido.

Outra definição interessante é a de escopo. Escopo é uma região textual de um programa em Python, onde um namespace é diretamente acessível. O escopo local de uma função é a região de codigo dela, onde podemos chamar suas variáveis diretamente.

Python tem duas funções muito interessantes, com elas podemos acessar os namespaces em tempo de execução, são elas locals() e globals().

A função locals() retorna um dicionário, onde as chaves são os nomes das variáveis locais, e os valores são os valores dessas varáveis. Vamos ver um exemplo:

def f(n):
....mult = n * 2
....print locals()

Obeserve a função acima f(n), 'n' é o argumento da função, argumentos também pertencem ao namespace local, e dentro da função criamos a variável 'mult'. Agora vamos chamar a função atribuindo um valor para 'n':

>>> f(4)
{'mult': 8, 'n': 4}

Obeserve que locals() retornou o dicionario acima, com as variáveis e seus conteúdos.
O mesmo que locals() faz para um namespace local, globals() faz para o namespace global.

>>> import locais
>>> globals()
{'__builtins__': module '__builtin__' (built-in), '__name__': '__main__', '__doc__': None, 'locais': module 'locais' from 'locais.py'}

Vamos entender o que foi feito acima, direto da linha de comando. Primeiro eu importei o módulo criado acima,chamado de locais.py, que contém o exemplo de locals(). Depois, eu chamei a função globals() e ela me retornou o dicionário acima.
'__builtins__', como eu já citei, é o módulo que contém todas as funções, excessões embutidas, o que forma o namespace embutido.
'__name__' funciona da seguinte maneira. Ao rodar um módulo, ao invés de importá-lo, o valor embutido __name__ será __main__. E como nós estamos da linha de comando, __name__ é __main__
E observe também a presença do módulo que foi importadom 'locais', ao ser importado ele pertence ao namespace global.
'__doc__': None, mostra que nosso módulo corrente não tem nenhuma docstring

Uma utilidade para essas funções é a formatação de string com dicionários, eu falei um pouco disso no post anterior sobre dicionários.

Fonte:
- Livro Mergulhando no Python
- Python tutorial

Argumentos Opcionais

Python nos permite dar valores padrões para argumentos de funções, assim caso tal argumento não seja definido, será usado seu valor padrão, tornando esse argumento opcional.
Para fazer isso, devemos nomear os argumentos que terão seu valor padrão:

>>> def info(nome, idade=18, curso='python'):

Pronto, a função 'info' acima, possui 3 argumentos, 'nome' é um argumento obrigatório, já 'idade' e 'curso' têm valores padrão '18' e 'python' respectivamente.

>>> info('igor') ## 1
>>> info('igor', 20) ## 2
>>> info('igor', curso='plone') ## 3
>>> info(nome='igor', idade=20) ## 4

Vamos analisar as chamadas acima:

## 1: Nesse caso, entramos somente com o argumento obrigatório, então tando 'idade' quanto 'curso' assumem seus valores padrão, '18' e 'python'

## 2: Agora definimos, além do argumento obrigatório, 'idade', que agora passa a ser '20', e seu valor padrão é ignorado. E 'curso' continua com seu valor padrão.

## 3: Mas e se eu quiser definir o argumeto opcional 'curso' mas usar o valor padrão para 'idade'? Simples. Nesse caso nós, fizemos isso, definimos o argumento obrigatório, e também o argumento opcional 'curso' como 'plone'. Deixando 'idade' com seu valor padrão.

## 4: Esse caso é so para mostrar que os argumentos obrigatórios também poder ser nomeados na hora da atribuição.

Funções lambda

Se você precisa de uma função para fazer algo simples, de apenas uma expressão, existe uma maneira bem prática pra fazer isso em Python, usando uma função lamba.
Elas funcionam como uma função normal, só que possuem uma unica linha.

>>> def f(x):
... return x*2
>>> f(3)
6

usando uma função lambda:

>>> f = lambda x: x*2
>>> f(3)
6

Também podemos usar uma função lambda sem atribuí-la a nenhuma variável

>>> (lambda y: y*3 )(2)
6

As funções lambda são sempre opcionais, tudo que fazemos com ela pode ser feito com uma função normal.

Conhecendo os Dicionários

Hoje vamos dar uma olhada nos dicionarios, um tipo de dados do Python. Vamos começar por sua sintaxe:

d = {'nome' : 'igor', 'idade' : 18, 'curso' : 'python' }

Os dicionarios guardam pares de chave/valor, no caso acima, as chaves sao: 'nome', 'idade' e 'curso'... e elas se referem a seus respectivos valores: 'igor', 18, 'python'.
É importante lembrar que as posições dos pares chave/valor não tem ordem fixa. Os valores podem ser de qualquer tipo, strings, inteiros, tuplas.

Acima criamos o dicionario 'd' da maneira mais clássica, mas existem outras, como a função 'dict':

>>> items = [('nome','igor'), ('idade', 18), ('curso','python')]
>>> d = dict(items)
>>> d
{'idade': 18, 'curso': 'python', 'nome': 'igor'}

Outra maneira interessante de se criar um dicionario, é usando o método 'fromkeys'

>>> dic = {}.fromkeys(['nome','idade'])
{'idade': None, 'nome': None}

Ao invés de None, podemos dar o valor padrão

>>> dic = {}.fromkeys(['nome','idade'],'NADA')
>>> dic
{'idade': 'NADA', 'nome': 'NADA'}

Agora vamos ao que mais interessa, manusear o dicionário...

>>> d['nome']
'igor'

Tem um pequeno problema, e se essa chave nao existisse?

>>> d
{'idade': 18, 'curso': 'python', 'nome': 'igor'}
>>> d['profissao']
Traceback (most recent call last):
File "", line 1, in ?
KeyError: 'profissao'

Pra evitar esse tipo de bug, existe o metodo 'get'

>>> d
{'idade': 18, 'curso': 'python', 'nome': 'igor'}
>>> d.get('nome')
'igor'
>>> print d.get('profissao')
None

Pra alterar o valor de uma chave é muito simples

>>> d['nome']
'igor'
>>> d['nome'] = 'sobreira'
>>> d['nome']
'sobreira'

Observe que eu substitui o valor da chave 'nome', e caso ela ainda não existisse, eu teria acabado de criá-la. Mas que tal verificar se determinada chave existe mesmo?

>>> 'nome' in d
True
>>> 'profissao' in d
False
>>> d.has_key('nome')
True

Pra apagar uma chave também é batante simples:

>>> d
{'curso': 'python', 'nome': 'igor', 'idade': 18}
>>> del d['nome']
>>> d
{'idade': 18, 'curso': 'python'}

Caso você queira ver o que está apagando, ao invés do 'del', pode usar o 'pop'

>>> d
{'idade': 18, 'curso': 'python'}
>>> d.pop('curso')
'python'

Mas eu não quero apagar so uma chave, quero limpar todo o dicionario. Pra isso tem o 'clear'

>>> d = {'nome': 'igor', 'curso': 'python'}
>>> d.clear()
>>> d
{}

Também podemos copiar todo o conteudo do dicionario, para um outro dicionario

>>> d = {'nome': 'igor', 'curso': 'python'}
>>> d2 = d.copy()
>>> d2
{'curso': 'python', 'nome': 'igor'}
>>> d2['curso'] = 'dicionarios'
>>> d2
{'curso': 'dicionarios', 'nome': 'igor'}
>>> d
{'curso': 'python', 'nome': 'igor'}

Observe que uma alteração em um, não altera o conteudo do dicionario copiado

Existe uma utilidade muito legal dos dicioanários, que é formatar string. Aqui vai um exemplo muito interessante

>>> dic = {'nome': 'igor', 'curso': 'python'}
>>> frase = 'meu nome e %(nome)s e estou estudando %(curso)s'
>>> print frase % dic
meu nome e igor e estou estudando python


Bem, espero ter esclarecido um pouco o uso de dicionarios.
Tomei como base o livro Begining Pyhton - From Novice to Professional, de Magnus Lie Hetland, que eu aconselho muito pra quem ta começando na linguagem.
Até a próxima...

Python Orientado a Objetos

Hoje vai a primeira dica enviada por um visitante do blog, um amigo, Flavio Ribeiro. Foi ele quem me aprensentou a linguagem Python, quando começamos o curso de Sistemas em Telecomunicações no CEFET-PB, e assim como eu, adora a linguagem e quer aprender cada vez mais sobre ela.

Bem, Python é uma linguagem Orientad a Objetos, e aqui Flavio dar uma introdução de como funciona esse tipo de programação:

Python Orientado a Objetos

Olá a todos, hoje vou tentar *introduzir* alguns conceitos de orientação a objetos e creio que isso também me ajudará a tirar algumas dúvidas sobre essa poderosa forma de programação.

A programação orientada a objetos visa prioritariamente o reaproveitamento de código, além de deixar o código mais legivel, elegante e (claro) menor.

Tudo comeca com uma Classe. Ela serve como fábrica de objetos (calma, jájá explico o que é um objeto), e é a base da POO. Tratando isso de uma maneira mais simples, vamos imaginar que você quer criar um joguinho onde terão vários personagens.

class Personagem:
   """ Classe que cria personagens do jogo """
   def __init__(self,Nome,Poder):
       """ Método construtor da classe, onde recebe os parametros Nome e Poder de cada bonequinho """
       self.Nome = Nome
       self.Poder = Poder
       print 'Criando personagem ',Nome,' com poder ',Poder
   def Correr(self):
       print self.Nome,' está correndo!'
   def Chute(self,Adversario):
       print self.Nome,' Deu um chute em ',Adversario


Vamos agora explicar: Uma classe chamada Personagem foi criada, e para que ela fabrique algum bonequinho, precisa satisfazer os parametros do método construtor (__init__). A fabricação dele é o que chamamos de objeto ou instância de classe, e agora iremos criar um:

>>> Smurf = Personagem('Papai Smurf',30)
>>> Criando personagem Papai Smurf com poder 30

Viu? Agora temos um objeto chamado Smurf, ou seja, demos vida ao Papai Smurf e ele está pronto pra correr!

>>> Smurf.Correr()
>>> Papai Smurf está correndo!

Agora, para o chute, você deve ter visto que na definição do metodo tem um parametro Adversario, notou? Então teremos que dizer quem vamos chutar!

>>> Smurf.Chute('Gargamel')
>>> Papai Smurf Deu um chute em Gargamel

Deu pra entender como funciona? Da mesma forma que criamos o objeto Smurf, poderemos criar mais inumeros personagens usando apenas essa classe Personagem, usando esses mesmos comandos que digitei acima.

Ainda tem dúvidas não é? O que aquele self representa? O que são aquelas três aspas no inicio dos métodos e da classe? Toda classe precisa de parametros iniciais?

Vamos lá:
O self representa uma váriavel de objeto. Sem o self, quando fossem criados dois ou mais objetos as variaveis iriam sempre ser alteradas e citando como exemplo o código acima, se o ultimo bonequinho chamado 'Tux' fosse criado, todos os outros bonequinhos iam passar a chamar-se Tux também, assim como iam passar a ter o mesmo poder do Tux. Com o self, cada váriavel corresponde ao seu objeto!

As três aspas são chamadas de Doc String. Quando um programa é muito extenso, essas doc strings são de extrema necessidade para que o programador se oriente, elas documentam o código. Olha só como funciona usando o mesmo código acima:

>>> Personagem.__doc__
>>> ' Classe que cria personagens do jogo '

Sacou?

Quanto a ultima pergunta, Não. Não é preciso que toda classe receba dados iniciais, eles podem ser manipulados após a criação dos objetos apenas adicionando metodos de set. Eu poderia criar mais um método ali chamado 'RecebeNome' onde só após a criação do objeto eu iria dar nome a ele.

Bem, pretendo continuar a fazer mini-tutoriais como esse a medida que eu for tomando maior conhecimento da linguagem python. Dessa vez foi apenas um esquente, e espero que tenha ajudado alguem.






Trabalhando com strings

Só pra não deixar o blog parado, vamos dar uma pequena olhada no que o Python pode fazer com strings, apenas alguns métodos. Primeiro vale lembra que em Python, tudo são objetos, então uma string também é um objeto, e tem varios metodos embutidos que facilitam seu manuseio e formatação. Não é preciso declarar variáveis, então para criar uma string, basta atribuir:

>>> nome = 'igor'
>>> nome
'igor'

Ou para tornar um outro tipo em string:

>>> numero = 12.45
>>> string = str(numero)
>>> string
'12.45'

As strings possuem aspas simples ou duplas, para o caso de precisarmos de algumas delas dentro da própria string:

>>> nome = "meu nome é 'igor' "
>>> nome
"meu nome é 'igor' "

E se quisermos escrever uma string usando varias linhas:

>>> nome = ''' estou
... aprendendo
... python'''
>>> nome
'estou\n aprendendo\n python'

Note que um carácter quebra de linha (\n) é adicionado automaticamente com o Enter.
Agora vamos brincar com letras maiúsculas e minúsculas:

>>> nome = 'igor sobreira'
>>> nome.capitalize()
'Igor sobreira'
>>> nome
'igor sobreira'
>>> nome = nome.capitalize()
>>> nome
'Igor sobreira'

capitalize() retorna a primeira letra de string em maiúscula, mas sem alterar o valor da string atual. Tambem tem o upper(), e o lower():

>>> nome = 'igor'
>>> nome = nome.upper()
>>> nome
'IGOR'
>>> nome.lower()
'igor'

Também é possivel procurar por um caracter numa string, mostrando seu índice, mas isso retornara um erro, caso nao encontre:

>>>nome = 'python'
>>> nome.find('t')
2

Outro método muito interessante é o split():

>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']

o argumento que splt() recebe, é onde a string será cortada, e retornara uma lista como o exemplo acima.

>>> pasta = '/home/python/programa.py'
>>> pasta = pasta.split('/')
>>> pasta
['', 'home', 'python', 'programa.py']

Agora vamos fazer o inverso:

>>> '/'.join(pasta)
'/home/python/programa.py'
>>> ' ---- '.join(pasta)
'----home----python----programa.py'

Agora o método que eu acho mais interessante de todos é o replace:

>>> nome = 'mergulhando em java'
>>> nome = nome.replace(' em java', ' no python')
>>> nome
'mergulando no python'
>>> nome.replace('mergulhando em ','')
'python'

O replace pode ser utilizado pra tirar aquele estaço que fica no começo ou no final da string, mas, como não é surpresa, o Python ja tem isso pronto, é o strip(), mas ele so tira do começo e/ou do final da string:

>>> nome = ' python e muito bom '
>>> nome.strip()
'python e muito bom'

Ahh..quase ia me esquecendo, concatenar strings! Isso é algo muito dificil, creio que é a maior dificuldade de quem começa na linguagem:

>>> comeco = 'aprendendo '
>>> fim = 'python'
>>> comeco + fim
'aprendendo python'

Bem, e o print de Python, pode ser usado como o 'printf' de C:

>>> print 'aprendendo %s' %'python'
aprendendo python


É claro que existem varios outros métodos para strings, esses são os mais usados, caso alguem lembre-se de outro, pode colocar nos comentários :)

MSN feito em Python

Ja saiu a primeira versão do Emesene, um messenger feito em Python e GTK, que da suporte ao protocolo MSN. Tem uma interface bastante intuitiva, leve e é multiplataforma.

Acabei de testar e gostei muito. Ainda faltam algumas funcionalidades, como transferências de aquivos e mostrar avatar de usuário. Mas uma versão mais completa estará disponivel.

Para fazer o donwload, aqui.

Segue alguns screenshots do Emesene rodando no meu Ubuntu.


Fonte: yguarata.org

Novo Nokia N800

A Nokia lançou seu novo internet tablet, o N800, que veio para susceder o N770. Essa linha de aparelhos é voltada para conexão com a internet, não funciona como celular, ele vem com wi-fi e bluetooth, e suporta aplicações voip. Sua ótima resolução de 800 x 480 é perfeita para visualizar paginas web, tem navegador Opera, plugin de Flash 7, suporte a javascript, etc.

Vem também com webcam VGA, microfone, auto-falantes, saida para fones de ouvido, mini-USB e dois slots SD, um interno e outro externo, que suportam até 2GB cada.

Mas o mais interessante é que o N800 roda em cima de uma plataforma livre, a plataforma Maemo, que é baseada em Linux, o que permite que desenvolvedores Linux portem facilemente suas aplicações.
Mais informações: Pythonologia, Garota sem Fio.

Extraindo HTML de uma página

Aproveitando a dica anterior sobre manipulação de arquivos, vou aprensentar uma biblioteca do Python usada pra extrair o codigo HTML de uma pagina web, a urllib.

É bem parecido como a abertura de um aquivo texto, o metodo mais basico é o urlopen:


import urllib
pagina = urllib.urlopen('http://www.v2windcenter.com')
codigo = pagina.read()
pagina.close()
print codigo


Para mais informações sobre o modulo urllib.

Manipulando arquivos

Uma coisa bem interessante em Python é a manipulação de arquivos, que é bastante simples. Vamos tomar como exemplo o arquivo 'texto.txt' :

>>> f = open( '/home/igor/texto.txt', 'w')

a função open possui três argumentos: nome do arquivo, modo e buffer, sendo os dois ultimos opcionais. No exemplo acima, eu usei o nome e o modo 'w'. Vamos falar um pouco sobre os possiveis modos:

Existem três tipos basicos de modos: 'w', 'r', 'a'. Write ('w') é usado para escrever algo no arquivo, apagando o que já havia nele, e caso o arquivo ainda não exista, ele será criado. Mas e se eu quiser apenas adicionar um texto sem apagar o que ja tinha la? Ai estamos falando no modo 'a' (append, pra quem conhece os metodos de listas isso deve ser familiar), agora todo o texto escrito será adicionado no final do que tinha anteriormente (lembrando que o texto inserido é no formato string, não tem nada a ver com listas), nesse caso, se o arquivo também não existir ele será criado sem problemas. E como era de se esperar, 'r' é usado para ler um arquivo já existente.

Mas ainda tem alguns modificadores de modos:

>>> f = open('/home/igor/texto.txt','r+')

quando um '+' é inserido no final de qualquer modo, ele possibilita tanto a leitura quanto a escrita.

>>> f = open('/home/igor/texto.txt','rb')

Esse 'b', adicionado ao lado de algum modo, manuseia o arquivo em binario, e não em texto, como é o padrão.
Caso não seja especificado nenhum modo na função open, sera atribuido 'r' (read), que é o padrão.

O terceiro argumento, também opcional é o buffer, caso seja 0 ou False, não haverá buffer, ou seja, toda vez que o arquivo for ser utilizado, ele será manuseado diretamente do disco rigido; ja se for 1 ou True, então haverá buffer, o arquivo será manuseado da memoria, o que deixa o processo mais rápido. Caso for declarado um numero maior que 1, esse numero indicara o nivel de buffer (em bytes).

Mas agora vamos ao que interessa, escrever:

>>> f = open('/home/igor/Python/texto','w')
>>> f.write('Ola Mundo!')

Como o modo padrão é texto, não é necessário a extensão .txt. Não podemos esquecer de fechar o arquivo:

>>> f.close()

Existem várias maneiras de ler o que está escrito, a basica é read()

>>> f = open('/home/igor/Python/texto', 'r')
>>> ler = f.read()
>>> f.close()
>>> print ler
Ola Mundo!

O metodo read() usado sem nenhum argumento, mostrará tudo que esta no aquivo, mas se quisermos ler apenas os tres primeiros caracters (bytes), podemos usar da seguinte maneira:

>>> f = open('/home/igor/Python/texto') #lembrando que o modo 'r' pode ser excluido pois e o padrao
>>> ler = f.read(3)
>>> print ler
Ola

Aqui apenas especificamos que so serão lidos os tres primeiros caracters (bytes), e caso queira ler o restante, o read() começará de onde parou

>>> restante = f.read()
>>> print restante
Mundo!

Agora vamos adicionar mais alguma coisa no nosso arquivo:

>>> f = open('/home/igor/Python/texto','a')
>>> f.write('\nOla Python')
>>> f.close()

Aqui usamos o 'a' (append), pra adicionar sem apagar o que ja havia no arquivo, e o '\n' é usado pra pular uma linha, lembrando que tudo é string. Agora vamos ver o resultado de outras maneiras:

>>> f = file('/home/igor/Python/texto', 'r')
>>> linha1 = f.readline()
>>> linha2 = f.readline()
>>> f.close()
>>> print linha1
Ola Mundo!

>>> print linha2
Ola Python

O readline() sem argumento, ira ler todo o conteudo de uma linha, porem é possivel dar um limite de caracters, assim como o read. linha1 guarda o conteudo da primeira linha, quando eu chamamos o readline() mais uma vez, ele vai começar a ler de onde tinha parado, ou seja, na segunda linha. Caso não tenha percebido, ao inves de open, usamos file, que da o mesmo resultado.

Pra quem é fã de lista (como eu), não poderia faltar um metodo que retornasse todo o conteudo do arquivo numa lista, e como tudo em Python, ele ja está pronto! É o readlines():

>>> f = open('/home/igor/Python/texto', 'r')
>>> ler = f.readlines()
>>> f.close()
>>> print ler
['Ola Mundo!\n', 'Ola Python']

Cada linha fica em um indice da lista, no formato de uma string.

Para verificar se o arquivo foi realmente fechado, basta digitar:

>>> f.closed
True

Bem...espero ter esclarecido um pouco sobre manipulação de arquivos em Python, alguma duvida, complementação ou correção, podem comentar ou mandar um email.

Primeiro post

Bem, nesse primeiro post, gostaria de dizer o que tenho em mente ao criar este blog. Basicamente pretendo colocar dicas sobre a linguagem de programação Python, tenho muito pouca experiência com programação, então como estou aprendendo Python, tudo que eu for aprendendo e achando interessante na linguagem, vou escrever um pouco, dando dicas.

Desse modo posso compartilhar o que vou aprendendo e principalmente, alguem que esteja lendo e tenha alguma dica a mais, alguma atualização, correção, poderá deixar nos comentarios, ou me mandar um texto completo para ser publicado (igor@v2windcenter.com), afinal a principal meta desse blog é essa, a troca de informações.

Como Python, assim como qualquer linguagem de programação, estão totalmente ligadas com tecnologia, também pretendo falar um pouco sobre novidades tecnológicas que venham a surgir.

Espero ajudar um pouco quem estiver começando no Python, assim como eu, e também receber algumas dicas, pois o principal objetivo desse blog é o aprendizado. :)