Archive for the 'Tutorial' category

Como criar um crawler pra Twitter

fev 07 2012 Published by under Programação, Tutorial, Web

Neste post vamos criar um crawler para recuperar tweets públicos. Tweets públicos são aqueles que não necessitam de autenticação, ou seja, não é necessário ter uma conta no Twitter para ler esses tweets. Com Python, é bem simples recuperar qualquer status do Twitter, para isso, vamos utilizar o pacote python-twitter, que pode ser instalado via setuptools:

$ easy_install python-twitter

Ou, pode ser baixado neste link. Para instalar, extraia o conteúdo, vá até a pasta onde foi extraído e faça:

$ python setup.py build
$ python setup.py install

O python-twitter provê acesso a API do Twitter via código Python.

Para ler a Api e buscar ajuda, faça:

$ pydoc twitter.Status
$ pydoc twitter.User
$ pydoc twitter.DirectMessage

Para começar a utilizar o python-twitter, basta importar o pacote e criar uma instância da classe twitter.Api():

import twitter
api = twitter.Api()

Então, é possível obter os últimos tweets públicos facilmente com a função GetPublicTimeline, que retorna uma lista contendo em torno de 20 objetos do tipo twitter.Status, o texto do tweet em si está no atributo text:

tweets = api.GetPublicTimeline()
for tweet in tweets:
    print tweet.text

Agora, para recuperar os 20 últimos tweets de um usuário específico, existe a função GetUserTimeline. Trocando ‘user‘ por um usuário real do twitter no código abaixo, você obtém uma lista semelhante a que foi retornada pela função GetPublicTimeline:

user_tweets = api.GetUserTimeline('user')
for tweet in user_tweets:
    print tweet.text

A função GetUserTimeline permite configurar a quantidade de tweets a serem recuperados através do parâmetro count:

user_tweets = []
tweets = api.GetUserTimeline(user, count=30)
for tweet in tweets:
    user_tweets.append(tweet.text.encode('utf-8') + '\n')
print user_tweets

Neste código utilizei a função encode para imprimir caracteres especiais em português.

Você pode encontrar mais detalhes das funções mostradas aqui na documentação da API, basta fazer no terminal:


$ pydoc twitter.Api

11 responses so far

Tornando o Vim uma IDE amigável pra Python

jan 10 2012 Published by under Ferramentas, Programação, Tutorial

Em um post anterior eu falei sobre como habilitar o auto-complete no vim pra código em python. Recentemente encontrei um post num blog com dicas mostrando como tornar o vim numa IDE completa pra Python. Testei algumas funcionalidades que tornaram o vim bem amigável pra programar e gerenciar código. Fiz todos os testes no Ubuntu, em outros sistemas Linux deve ser similar. Neste post vou passar essa experiência que tive configurando e usando o vim para criar código python.

Antes de tudo, instale os pacotes vim-full e vim-python se estiverem disponíveis nos repositórios do seu sistema. As configuração no vim são feitas num arquivo chamado vimrc, nas últimas versões do Ubuntu ele fica localizado na pasta /etc/vim e precisa ser root para modificá-lo.

Destaque de código

Para habilitar highlighting (destaque do código) no vim adicione a seguinte linha no arquivo vimrc:

syntax on

No seu arquivo vimrc pode ser que esta linha venha comentada e acompanhada das seguintes linhas:

if has("syntax")
    syntax on
endif

Basta descomentar estas linhas que o highlighting ficará disponível.

Indentação

Como a indentação em Python é fundamental, sem ela podem ocorrer erros no código, uma ide que  tenha auto-indentação é ideal.  No arquivo vimrc procure as seguintes linhas e descomente ou adicione se elas já não estiverem no arquivo:

" Habilita auto-indentação
if has("autocmd")
 filetype plugin indent on
endif

Número de linhas

Para exibir o número das linhas no vim adicione o seguinte no vimrc:

" Habilitar número de linhas
set number

" Alternar exibição de número de linhas (facilita na hora de copiar)
nnoremap <F2> :set nonumber!<CR>: set foldcolumn=0<CR>
Vim com highlighting para Python e número de linhas

Vim com highlighting para Python e número de linhas



Navegação pelo código


Uma funcionalidade muito útil é a navegação pelo código. Com esta ferramenta habilitada é possível ver todas as classes e funções presentes no seu código e poder pular automaticamente pra qualquer uma delas.


Primeiro, é preciso instalar o pacote exuberant-ctags, disponível no repositório com este mesmo nome. Depois, baixe o taglist, que é um plugin do vim. Coloque o arquivo taglist.vim na pasta ~/.vim/plugin e o taglist.txt na pasta ~/.vim/doc, vá até esta última pasta, inicie o vim e rode :helptags. (com ‘.’ no final) e já estará instalado.


Vim com code explorer
Code Explorer para o Vim


Agora é preciso fazer algumas alterações no vimrc:


" Exibe nome da função
let g:ctags_statusline=1
" Inicializar script automaticamente
let generate_tags=1
" Exibe os resultados em uma janela vertical
let Tlist_Use_Horiz_Window=0
" Atalho para exibição da Taglist
nnoremap TT :TlistToggle<CR>
map <F4> :TlistToggle<CR>
" Configurações para exibição da Taglist
let Tlist_Use_Right_Window = 1
let Tlist_Compact_Format = 1
let Tlist_Exit_OnlyWindow = 1
let Tlist_GainFocus_On_ToggleOpen = 1
let Tlist_File_Fold_Auto_Close = 1



A Taglist estará disponível através do atalho F4 ou digitando “TT” (dois ‘t’ maiúsculos)

As últimas configurações servem para exibir uma janela vertical à direita mostrando a taglist e ganhar foco quando é chamada.


Ocultar Código


Quando o seu código começa a ter muitas funções e classes fica difícil ter uma visão geral do que está disponível no código. A maioria das IDE’s possuem uma funcionalidade para ocultar parte do código e mostrar somente a assinatura ou definição de classes e funções.


No Vim isso é possível através de um plugin. Para instalá-lo baixe o arquivo neste link, crie uma pasta chamada ftplugin dentro da pasta ~/.vim e copie o plugin para a pasta ftplugin. A tecla ‘F’ (<Shift> + f) oculta ou exibe todo o código dentro de funções e classes, enquanto que a tecla ‘f” exibe ou oculta o código onde está o cursor.


Ocultar código automaticamente no Vim
Ocultar código no Vim


Project Explorer


Essa é uma das principais funções de uma IDE: organizar seu projeto. No Vim é preciso instalar o plugin NerdTree, que pode ser baixado aqui. Para instalar basta extrair o conteúdo do arquivo .zip na pasta ~/.vim. Rode  :helptags. (com ‘.’ no final) e rode :help NERD_tree.txt para ver o arquivo de ajuda. Pra utilizar o plugin digite :NERDTree e será aberta uma janela com o conteúdo da pasta atual.


Na página de scripts do vim, você pode encontrar outros plugins de Python para o vim. Se você testar algum outro plugin ou tiver uma funcionalidade interessante que eu não comentei no post, deixe sua experiência nos comentários.

                    			

            

				One response so far	
            
	          
	        

      	        

            
Criando um crawler pra páginas HTML com BeautifulSoup

            

				

					dez 31 2011					Published by  under Programação, Tutorial, Web 				

			 

			      

              

											
										
Neste post vamos aprender a como criar um crawler pra recuperar páginas HTML utilizando o BeautifulSoup com Python. O BeautifulSoup pode ser usado para arquivos HTML ou XML, com ele fica muito simples navegar e buscar textos em páginas HTML. Uma grande vantagem da BeautifulSoup é que ela consegue criar uma estrutura mesmo com páginas html mal formatadas, facilitando o trabalho do programador.


Inicie o interpretador Python para testar os códigos que vamos apresentar a seguir.


Para processar páginas HTML, importe o BeautifulSoup da seguinte forma:


from BeautifulSoup import BeautifulSoup



Se você for processar arquivos XML:


from BeautifulSoup import BeautifulStoneSoup



Por enquanto vamos processar apenas páginas html.

Vamos usar a biblioteca urllib2 para recuperar uma página html.


import urllib2
pagina = urllib2.urlopen("http://www.globo.com").read()



Isso vai criar uma string com todo o código html da página.

Então, para criar o parser basta:


soup = BeautifulSoup(pagina)



É possível transformar esse objeto BeautifulSoup em string com o método prettify, que manipula o código bruto adicionando quebra de linha e espaçamento recriando a estrutura do código html.


soup.prettify()



Para listar todos os links da página recuperada, usamos o método findAll:


links = soup.findAll('a')



Neste código, ‘links‘ é uma lista contendo objetos do tipo Tag da biblioteca BeautifulSoup (class BeautifulSoup.Tag). Vamos agora, listar somente os links (tirando qualquer texto ou marcação) que estão nesses objetos Tag:


for link in links:
    print link['href']



Para recuperar somente uma área da página, é possível usar o método find com o parâmetro id, por exemplo:


colunas = soup.find(id="glb-area-colunas")
linkscol = colunas.findAll('a')
for link in linkscol:
    print link['href']



A biblioteca BeautifulSoup facilita muito na hora de criar parsers e crawlers para páginas html ou xml. Usada junto com o urllib2 são poderosos aliados na recuperação de informação na web.

                    			

            

				No responses yet	
            
	          
	        

      	        

            
Tutorial básico de NumPy

            

				

					out 25 2011					Published by  under Ferramentas, Programação, Tutorial 				

			 

			      

              

											
										
NumPy é um pacote de Python que  suporta operações com vetores e matrizes e é essencial para a computação científica com Python. O NumPy é baseado em C, portanto tem um desempenho superior se comparado às operações com vetores originais do Python. Neste post eu quero mostrar uma introdução básica ao NumPy para os iniciantes.


INSTALAÇÃO


Primeiro vamos instalar o NumPy. No Windows, basta baixar a última versão do numpy no site do SourceForge e instalar facilmente com o arquivo .exe. No Linux, instale o pacote “python-numpy” ou mesmo usando o easy_install numpy.


Pronto, agora é só abrir o console Python e importar o pacote:


>>> import numpy as np


CRIAÇÃO DE ARRAY


Para criar um array, é bem simples:


>>> a = np.array([0,1,2,3,4,5])
>>> a
array([0,1,2,3,4,5])




A função array do NumPy, recebe uma lista de Python e transforma em um array NumPy. Você pode checar o tipo:


>>> type(a)



E o tipo dos elementos:


>>> a.dtype



Para criar matrizes multidimensionais é bem simples também:


>>> a = np.array([[0,1,2,3], [4,5,6,7], [8,9,10,11]])



A função arange é bem parecida com a função range, só que retorna um array ao invés de uma lista:


>>> x = np.arange(11.)
array([  0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])



É possível definir mais parâmetros pra função arange:


>>> x = np.arange(10, 30, 5) #(limite inferior, limite superior, passo)
array([10, 15, 20, 25])



TAMANHO DO ARRAY


A propriedade shape mostra o tamanho de cada dimensão da matriz:


>>> a.shape
(3,4)



É possível, também, modificar essa propriedade:


>>> a.shape = (2,6)
>>> a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])



ACESSANDO ELEMENTOS


Para acessar elementos:


>>> a[1,3]
9



É possível acessar vários elementos ao mesmo tempo:


>>> a[0,3:5]


matriz de inteiros
Fonte: SciPy 2011 - Jonathan Rocher


 array([3, 4])


>>> a[4:,4:]

 array([[44, 45],

 [54, 55]])


>>> a[:,2]

 array([2,12,22,32,42,52])


>>> a[2::2,::2]

 array([[20, 22, 24],

 [40, 42, 44]])


MATRIZ TRANSPOSTA


Para obter a matriz transposta existem duas formas:


>>> a.transpose()
>>> a.T
array([[ 0, 4, 8],
 [ 1, 5, 9],
 [ 2, 6, 10],
 [ 3, 7, 11]])



FUNÇÕES IMPORTANTES


A função sum soma todos os elementos do array:


>>> np.sum(a)
66



Podemos usar o parâmetro axis e determinar em qual eixo queremos a soma:


>>> np.sum(a, axis=0)
array([12, 15, 18, 21])
>>> np.sum(a, axis=1)
array([ 6, 22, 38])



Alternativamente, podemos usar o método sum:


>>> a.sum()
66
>>> a.sum(axis=0)
array([12, 15, 18, 21])



As funções amin e amax retornam o valor mínimo e o valor máximo do array, respectivamente:


>>> b = np.array([3.4, 5., 33., 8.])
>>> np.amin(b)
3.4
>>> np.amax(b)
33.0



argmin e argmax retornam o índice do menor valor e do maior valor do array, respectivamente:


>>> b.argmax()
2
>>> b.argmin()
0



O atributo flat retorna um iterator que permite acessar elementos de um array multidimensional como se ele fosse uma lista:


>>> a = np.array([[0,1,2,3], [4,5,6,7], [8,9,10,11]])
>>> a.flat
<numpy.flatiter object... >
>>> a.flat[:]
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])



Existem ainda outras diversas funções que podemos explorar em outro post.

                    			

            

				No responses yet	
            
	          
	        

      	        

            
Entendendo Decorators de forma simples

            

				

					out 24 2011					Published by  under Programação, Tutorial 				

			 

			      

              

											
										
O que é quando usar um decorator:


Sabe aquela trecho de código que vive se repetindo no seu código e você acha um saco ter repetir? Imagine que esse trecho repetido necessite uma refatoração e imagine que seu projeto é grande você já começa a vislumbrar um cenário caótico.


As boas práticas de programação tentam prevenir este tipo de problema. Mas tem horas que nem o seu mega modelo resolve. Um caso simples é quando o trecho de código que se repete necessita de parametrização ou muda de acordo com o contexto.


Decorators são uma tentativa de “economizar” código, manter a sanidade e as boas práticas de programação. Ok, eu sei que a razão principal de um decorator não é essa. Dá uma passada na PEP para descobrir mais. O lance é meio inception. Então eu curto a minha explicação… ;) 


Então, se você viu um @ em cima de um método no código. Parabéns, você já sabe o que é um decorator e provavelmente já utiliza.


Criando um decorator:


- “mas eu quero criar um decorator”


Ok. Para fazer isso é simples:


Defina um método cujo o parametro será a assinatura de uma função decorada.


Então brinque com a função e retorne a função ou outra função. Lindo não? (se lembra que eu disse que era meio inception?)


Mas o decorator é isso mesmo. É um cara que vai pegar sua função bonitinha é modifica-la. Ou mesmo desfigura-la. Vou mostrar como cria um decorator brincando.


Suponha que você criou uma função de somar:


def sum(a,b)
  return a+b



Função linda! Bom agora vou bagunçar a vida do cidadão que usa essa função e fazer que a soma seja a – b. Mas eu não quero perder o código original. Isto é um trabalho para o decorador:


def bagunca(funcao):
  def subtrai(a,b):
   return a-b
 return subtrai

@bagunca
def sum(a,b):
  return a+b



Bom, agora deixo com vocês executarem o código no terminal e compreende que aconteceu com a função sum. Acredito que desta forma você compreenderá o uso do decorator.


até a próxima,

                    			

            

				No responses yet	
            
	          
	        

      	        

            
Transformando seu código Python em executável com o py2exe

            

				

					set 14 2011					Published by  under Ferramentas, Programação, Tutorial 				

			 

			      

              

											
										
Em diversas situações é necessário criar um arquivo executável a partir do seu código. Às vezes é preciso entregar um programa a um cliente que não tem Python instalado ou não tem as diversas bibliotecas que você usou pra criar sua aplicação. Ou até mesmo no caso de você querer usar o seu programa em qualquer outra máquina Windows sem precisar da instalação do Python. Neste post vamos fazer um tutorial sobre como fazer isso utilizando o py2exe.


INSTALAÇÃO


O primeiro passo é instalar o py2exe. Pra isso basta ir ao site e baixar a última versão. Baixe a versão para o seu Windows (32 ou 64 bits) e de acordo com a versão do python (2.5, 2.6, 2.7…).  A instalação é simples e padrão. Após a instalação adicione a pasta de scripts ao PATH do sistema, geralmente C:\Python27\Scripts.


TUTORIAL


Primeiro vamos escrever um código qualquer em Python. Você pode escrever um código importando qualquer pacote, desde que este esteja instalado no seu sistema. Para este exemplo você pode escrever seu próprio código, eu vou dar um simples exemplo utilizando a biblioteca matemática do Python, crie um arquivo em qualquer pasta chamado calc.py e escreva o seguinte código:


import math
def main():
    modelo = raw_input("Digite 1 para seno e 2 para cosseno: ")
    n = raw_input("Entre com um número: ")
    choice = int(modelo)
    num = float(n)

    if choice == 1:
        print math.sin(num)

    elif choice == 2:
        print math.cos(num)

if __name__ == "__main__":
    main()



Teste o seu código:


C:\Pythonize> python calc.py


O segundo passo é criar um script de setup. Crie um arquivo chamado setup_calc.py na mesma pasta que você salvou o código anterior e escreva este código:


from distutils.core import setup
import py2exe
setup(console=['calc.py'])



Pronto, para criar seu arquivo executável, rode seu script:


C:\Pythonize> python setup_calc.py py2exe


Serão criadas duas pastas: build e dist. A pasta build é usada somente para compilar o código e criar o executável e pode ser excluída após o término do processo. A pasta dist contém os arquivos necessários para rodar sua aplicação. Agora você pode testar seu executável:


C:\Pythonize>cd dist


C:\Pythonize\dist>calc.exe


Digite 1 para seno e 2 para cosseno: 1


Entre com um número: 4


-0.756802495308


Funcionando muito bem!


Se você quer distribuir seu programa e levar para outro computador Windows, é preciso levar toda a pasta dist para que sua aplicação funcione corretamente. Para outras informações, veja o tutorial do py2exe.


Para utilizar o py2exe com outros pacotes e módulos, veja o link: Working with Various Packages and Modules.

                    			

            

				2 responses so far	
            
	          
	        

      	        

            
Introdução à programação em Cython

            

				

					set 10 2011					Published by  under Programação, Tutorial 				

			 

			      

              

											
										


Quando o seu programa exige muita velocidade, não tem jeito, o código tem que ser escrito em C. Mas todo programador sabe o quão penoso pode ser programar em C e os diversos problemas que podem surgir no seu código contribuindo com o atraso na entrega do programa final. E porque não juntar a facilidade de programar em Python com a rapidez de execução de C? Essa é a proposta do Cython, uma extensão Python que permite que sejam utilizados tipos de C dentro do código Python.


INSTALAÇÃO


O primeiro passo é a instalação. Você pode instalar o Cython através do setuptools, digitando, na linha de comando:


$ easy_install cython


Esse comando funciona tanto na linha de comando no Linux, quanto no prompt do Windows.


Se você não tem instalado o setuptools no Linux basta procurar pelo pacote homônimo e instalá-lo. No Windows, basta baixar o executável, na página do pacote e instalar.


Uma alternativa é baixar o Cython no site, extrair os arquivos e fazer na linha de comando:


$ python setup.py install


Dica do Francisco:


Em sistemas Debian e derivados, é possível instalar o cython pelo apt-get:


$ sudo apt-get install cython


TUTORIAL


Para utilizar Cython em seu código, é preciso primeiro criar um arquivo com extenção .pyx. Para um primeiro teste crie um arquivo chamado helloworld.pyx e escreva a seguinte linha:



print "Hello World"




Em seguida, crie um arquivo chamado setup.py que tenha o seguinte conteúdo:


from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

setup(
    cmdclass = {'build_ext': build_ext},
    ext_modules = [Extension("helloworld", ["helloworld.pyx"])]
)



Então, basta compilar utilizando o seguinte comando:


$ python setup.py build_ext –inplace


Depois é só entrar no interpretador e importar o módulo criado:


>>> import helloworld

Hello World


Vamos avançar e criar um código que realmente tenha tipos de dados de C. Vamos criar uma função que retorne todos os números primos de 1 até um limite passado como parâmetro e salvar num arquivo chamado primes.pyx:


def primes(int kmax):
    cdef int n, k, i
    cdef int p[1000]
    result = []
    if kmax > 1000:
        kmax = 1000
    k = 0
    n = 2
    while k < kmax:
        i = 0
        while i < k and n % p[i] != 0:
            i = i + 1
        if i == k:
            p[k] = n
            k = k + 1
            result.append(n)
        n = n + 1
    return result



Para declarar tipos C, você deve usar cdef e informar o tipo de dado, como nas linhas 2 e 3. Na linha 3, como qualquer array em C, deve ser informado o tamanho do array.


Nas linha 9 e 11 é que aparece o ganho no desempenho, a iteração dos blocos while é feita com tipos C, que torna a execução mais rápida.


Feito isso, basta criar o arquivo setup.py, como no exemplo anterior:


from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

setup(
    cmdclass = {'build_ext'},
    ext_modules = [Extension("primes", ["primes.pyx"])]
)



E compilar com o comando:


$ python setup.py build_ext –inplace

                    			

            

				2 responses so far	
            
	          
	        

      	        

            
Programando em Python no Vim

            

				

					set 08 2011					Published by  under Ferramentas, Programação, Tutorial 				

			 

			      

              

											
										
No Linux, um bom editor para código Python é o Vim. Costumo usar o Vim no Ubuntu e tem sido uma boa experiência. O Vim pode ser instalado também no Windows e é um bom substituto para o IDLE. Você pode fazer o download da versão para Windows no site do Vim. Versões recentes do Vim possuem suporte para Python nativo. Para ter certeza disso abra o Vim e digite :python print “hello world” (com dois pontos antes da palavra python). No Windows isso vai funcionar com o gVim.


O gVim já tem auto-identação e highlighting pra Python. Para ter o code completion no Vim é necessário ter um plugin instalado. Na versão 7.3 para Windows o omni completion já veio disponível, para testar bastar digitar ctrl+x e ctrl+o, que vai abrir uma janela dropdown com diversas opções. No Linux, para habilitar o omni completion, adicione a seguinte linha no arquivo /etc/vim/vimrc:


autocmd FileType python set omnifunc=pythoncomplete#Complete


Outras funções interessantes que podem ser adicionadas ao Vim para codificação Python podem ser vistas em: VIM as Python IDE.


Update (17/02/12): Escrevemos  um post mais completo sobre como utilizar o Vim como IDE pra Python.

                    			

            

				One response so far	
            
	          
	        

      	        

            
Programando em Python no IDLE

            

				

					set 08 2011					Published by  under Ferramentas, Programação, Tutorial 				

			 

			      

              

											
										
Depois da instalação do Python e alguns testes vamos pôr a mão na massa e trabalhar de verdade com arquivos de código. Todo código que você faz no interpretador é perdido quando você fecha o interpretador. Mas eu fiz muito código legal e vou simplesmente perder tudo? Python também trabalha com arquivos de código que você pode salvar em sua máquina para rodar depois.


Os arquivos Python têm extensão .py. É possível rodar um arquivo Python a partir da linha de comando da seguinte forma:


$ python nome_do_arquivo.py


Com isso todo o código que está salvo no arquivo é transformado em bytecode, que é um arquivo binário usado pelo interpretador. O bytecode é multiplataforma, ou seja, você pode levar seu código pra rodar em qualquer máquina e qualquer sistema. O bytecode é armazenado em sua máquina geralmente com a extensão .pyc, quando você executar seu código novamente sem alterações o programa não precisa ser compilado de novo, sendo executado mais rápido. Sempre que o seu código fonte é alterado, o interpretador gera um novo bytecode.


Você pode escrever seu código no tradicional bloco de notas, mas existem diversas alternativas para escrever código Python e eu recomendo fortemente que não seja escrito no bloco de notas. Existem vários editores de texto e IDEs próprias pra se escrever código em Python. No Windows temos o Notepad++ que tem highlighting (destaca palavras especiais e seu código em cores) ou o próprio IDLE que também vem com highlighting, auto-identação e outros recursos que facilitam a criação do código. No Linux tem o Vim, que possui todos esses recursos citados anteriormente ou o Kate. Você pode ver outros editores na lista de editores Python e também IDEs que suportam Python.


Neste post vamos tratar do IDLE para Windows em outro post vou falar do Vim no Linux, se alguém tiver experiência com outros editores ou IDEs, por favor compartilhe conosco nos comentários.


IDLE


O IDLE, além de ter uma linha de comando Python, também é usado como editor de arquivo fonte. Com a janela principal do IDLE aberta vá ao menu File->New Window e será aberta uma janela em branco onde é possível escrever o código.


Vamos fazer um pequeno teste. Na nova janela aberta digite o código que está na imagem (print “Hello World”):


Hello World no IDLE


Salve o arquivo com o nome: helloworld.py


Você já pode perceber a função highlighting nesse código.


Nesta mesma janela, vá ao menu Run->Run Module ou aperte a tecla F5. Vai ser impresso o texto Hello World na tela do interpretador.


Vamos avançar um pouco mais. Escreva o seguinte trecho de código no IDLE:


# -*- coding: latin1 -*-
x = 7*3        #Isto é um comentário
y = "Hello"     #Este é mais um comentário
if y == "Hello":
    x = x + 1
    y = y + "World"    #Concatenação de strings
print x
print y



Aqui, mais uma função do IDLE: auto-identação, assim que você digita linha 4 e dá Enter, o IDLE identifica um novo bloco de código. O Python identifica blocos de código através da identação, diferente de outras linguagens como C e Java que identificam blocos entre chaves ({}).


Outras funções interessante estão no menu Format na janela de edição de código.


Menu Format no IDLE


Neste menu você pode identar ou tirar identação de um trecho selecionado, é possível comentar ou descomentar o código, transformar tab em espaços ou vice-versa.


Dúvidas, opiniões, sugestões e experiências, postem nos comentários!

                    			

            

				One response so far	
            
	          
	        

      	        

            
Iniciando a programação em Python

            

				

					set 04 2011					Published by  under Programação, Tutorial 				

			 

			      

              

											
										
Neste blog vou apresentar o que eu aprendi de Python durante mais de três anos e minhas experiências diárias com a linguagem. Vou começar do início, mostrando para aqueles que estão iniciando na linguagem a como programar em Python. Não vou dizer por que você deve programar em Python. Eu programo em Python porque acho uma linguagem simples e poderosa, com poucas linhas de código você consegue criar uma aplicação completa rapidamente. Gosto de Python também porque possui muitas ferramentas que facilitam o dia-a-dia do desenvolvimento de software tanto comercial quanto científico. Então vamos ao que interessa, pra programar em Python você precisa ter o Python instalado em sua máquina.


Instalação para os usuários Linux/Mac OS X


Se você usa uma distribuição Linux, seja Ubuntu, Fedora, OpenSUSE, CentOS, etc… ou se você usa o Mac OS X é bem provável que o Python já esteja instalado, basta abrir um terminal (konsole, para KDE ou gnome-terminal para Gnome) e digitar “python” (sem aspas) que o interpretador Python irá iniciar.


Shell Python Linux
Interpretador Python no Shell do Linux


Instalação para os usuários Windows


Para os usuários de Windows é necessário instalar o interpretador Python. Visite o site http://www.python.org/download/ e baixe a última versão. Python mantém duas versões: 2.7.x e 3.2.x. Se você não sabe qual escolher, vá de 2.7, pois muitas ferramentas e frameworks são compatíveis somente com a versão 2.7. Instale normalmente, como qualquer outro instalador Windows. Depois da instalação é preciso configurar a variável PATH do sistema. No Windows 7, abra o Painel de Controle, na pesquisa (no canto superior direito)  digite “variáveis de ambiente” (sem aspas) e clique em “Editar variáveis de ambiente para sua conta”. Na seção: “Variáveis de usuário” clique na variável PATH ou crie uma com este nome e no campo “Valor da variável” digite: “;C:\Python27” (sem aspas) no final do texto que já estiver lá (isso se você instalou o Python na pasta raiz C:\)


Pronto, agora abra o prompt de comando e digite python, você terá o interpretador Python pronto pra trabalhar.


Python na linha de comando
Chamando o interpretador Python na linha de comando


Como alternativa, junto com o Python é instalado um ambiente Shell de desenvolvimento, o IDLE, que você pode usar como interpretador (da mesma forma que no cmd) ou como editor de arquivos Python.


IDLE
IDLE Python


Primeiros passos no interpretador


Com o Python devidamente instalado no seu sistema, vamos fazer alguns testes para ter as primeiras impressões da programação em Python. Vamos então, usar o prompt do interpretador Python. Você pode usar o IDLE ou iniciar o interpretador Python na linha de comando. Para imprimir qualquer texto na linha de comando, basta digitar print seguido de um texto entre aspas. Por exemplo:


>>> print “Hello World!”


Hello World


>>> print “Meu primeiro teste em Python.”


Meu primeiro teste em Python.


Bem simples, e você já fez o clássico “Hello World” em Python.


O interpretador Python pode ser usado como calculadora:


>>> 2+8


10


>>> 9*7


63


Digite o seguinte no interpretador:


>>> import math


Fazendo isso você estará carregando o módulo de funções matemáticas de Python. Com isso estarão disponíveis diversas funções matemáticas pra você testar:


>>> math.sqrt(16)


4.0


>>> math.exp(4)


54.598150033144236


>>> math.pow(5,3)


125.0

                    			

            

				No responses yet