associação pythonbrasil[11] django zope/plone planet Início Logado como (Entrar)

Diferenças para "IntroPython"

Diferenças entre as versões de 50 e 89 (39 versões de distância)
Revisão 50e 2004-12-15 16:20:18
Tamanho: 23046
Editor: 201-002-075-247
Comentário:
Revisão 89e 2008-06-04 22:46:27
Tamanho: 36455
Editor: RafaelJorge
Comentário:
Deleções são marcadas assim. Adições são marcadas assim.
Linha 5: Linha 5:
Este é o Guia do PythonBrasil, para uma rápida introdução à linguagem Python. O guia inicia contextualizando Python, para em seguida tratar da estrutura da linguagem propriamente dita.

Este tutorial exige que se tenha algum conhecimento em programação, saber que um programa é a maneira que dizermos ao computador como efetuar (passo-a-passo) alguma tarefa já é um bom começo! O conhecimento básico de algoritmos e estruturas de dados.

=== O que é Python ===

O Python é uma linguagem de programação moderna, de sintaxe agradável e recursos poderosos. A linguagem tem alguns pontos que a tornam especial:

    * É uma linguagem interpretada. Não é necessário perder tempo no processo de editar, compilar e executar. Basta editar e executar para ver o resultado.

    * É uma linguagem de tipagem dinâmica. Não se declarara o tipo de variáveis, retornos de funções e parâmetros. Os tipos são identificados de acordo com o uso que fazemos deles.

    * O controle de bloco de comandos é feito apenas por alinhamento, não há delimitadores do tipo {{{Begin}}} e {{{End}}} do Pascal ou { e } da linguagem C. Não se assuste, isso pode ser muito interessante!

    * Oferece tipos de dados de alto nível como ''strings'' de verdade, dicionários (também conhecido por ''hashes'' ou arranjos associativos), listas, tuplas, classes, etc.

    * É orientada a objetos. Aliás, tudo em Python é um objeto inclusive os tipos primitivos.

    * Aceita outros paradigmas de programação bastantes úteis, como a programação modular, para evitar a "poluição" de nomes e a programação funcional, que descreve mais facilmente determinadas estruturas.

Nas próximas seções estes aspectos serão discutidos com mais detalhes.

''Em parte retirado de: http://www.async.com.br/projects/python/pnp/node3.html''

== O que eu posso fazer com Python? ==

Praticamente tudo o que se faria com qualquer linguagem de programação, seja ela interpretada ou compilada. Pode-se fazer protótipos de sistemas, automatizar tarefas repetitivas como manipulação de texto, cópia de arquivos e outros (fazer ''scripts'' como é comumente conhecido).

Pode-se também criar programas que funcionam no modo texto, tanto interativos como servidores (ou daemons). Pode-se fazer programas em modo gráfico usando a interface nativa do seu sistema, ou então utilizando Tk, GTk, Qt, wxWidgets e tantas outras. Programas que operam em rede e Internet, banco de dados, escrever aplicações comerciais e científicas. A lista é grande e só depende da criatividade do programador!

== O que eu não posso fazer com Python? ==

Em teoria, qualquer coisa, mas, na prática, devido à recursos de CPU, implementação e uso de memória, isso nem sempre é verdade. Criar um ''kernel'' de um sistema operacional a partir do zero poderia até ser feito, mas, com certeza, o desempenho seria pouco adequado para o uso no mundo de verdade, não passaria de um brinquedo.

Em resumo, sistemas de muito baixo nível, como ''kernel'' de sistema operacional ou rotinas relacionadas e controladores de dispositivos, são pouco adequados de serem desenvolvidos em Python. Para isso, é melhor utilizar-se de uma linguagem compilada, como C ou C++.

== Por que eu deveria usar Python e não Perl, Java ou outra linguagem? ==

Python e Perl são linguagens com propósitos bastante parecidos. A vantagem do Python que chama mais atenção é a sua consistência e facilidade de leitura (e se você já programou em Perl, sabe que isso é importante! Alguém tem/quer exemplos?).

Python e Java são linguagens bem diferentes, o que torna a comparação difícil ou sem signficado. Python sugere um desenvolvimento rápido, do tipo "editar-executar" (Python compila automaticamente quando executamos o programa). Java exige que o programador declare tipos, visibilidade de funções, separe cada classe (pública) em arquivos diferentes, e o desenvolvimento é do tipo "editar-compilar-executar" (ainda que o arquivo gerado tenha que ser interpretado...). Outra vantagem do Python são suas estruturas de dados tais como listas e dicionários que são nativas à linguagem. Java usa classes de sua biblioteca padrão para prover essas funcionalidades, mas geralmentes são necessários muito mais comandos (e ''casts'') para obter o mesmo resultado. Outras diferenças significativas são: a tipagem dinâmica do Python e sua natureza multiparadigma (enquanto o java força a orientação a objetos, o Python permite o uso de outros paradigmas como a programação funcional)

== De onde eu adquiro o Python? ==

O site oficial é: http://www.python.org/, para baixar os arquivos para poder instalar o interpretador e a biblioteca padrão basta ir no endereço http://www.python.org/download/.

=== Linux ===

Para instalar o Python em Linux você dispõe de 2 opções:
   1. Baixar os códigos fontes, compilar e instalar
   2. Instalar um pacote que geralmente já vem com sua distribuição Linux.

Para instalar a partir dos fontes basta seguir os procedimentos abaixo:
   * Baixe o arquivo com os fontes [http://www.python.org/download/ aqui].
   * Descompacte os fontes:

{{{
$ tar zxvf Python-VERSAO.tgz
}}}

   * Certifique-se que as bibliotecas necessárias para compilar o Python e os arquivos de cabeçalhos dessas bibliotecas (geralmente esses arquivos ficam nos pacotes {{{-devel}}} das distribuições) estejam instalados:
      * glibc (ou outra libc)

   * Compile:
{{{
$ ./configure
$ make
# make install # esse comando deverá ser executado como root
}}}

   * Adicione o diretório do interpretador no {{{PATH}}} caso ele ainda não esteja e teste para ver se tudo está funcionando corretamente:
{{{
$ PATH=$PATH:/usr/local/bin; export PATH
$ python
}}}

=== Windows ===

No site oficial tem um instalador para Windows que é muito simples! Nem parece que está instalando uma linguagem de programação...

=== Macintosh ===

Você poder baixar um instalador binário Python no site:

http://homepages.cwi.nl/~jack/macpython/download.html



== Entendendo Python ==
== Apresentação ==

Bem-vindo(a) ao nosso guia de introdução à linguagem Python. Este guia exige que se tenha noção de linguagens de programação e para isso é necessário saber o que são algoritmos e estruturas de dados. Quem já programou em uma outra linguagem, como Visual Basic, Delphi ou C poderá se sentir mais apto a programar em Python com esse guia.

Quem sabe você tem dúvidas conceituais sobre a linguagem. Se for este o seu caso, faça uma leitura na seção de [http://www.pythonbrasil.com.br/moin.cgi/PerguntasFrequentes/SobrePython Perguntas e Respostas freqüentes sobre Python].

Pronto para começar? Talvez não, porque é necessário ter certeza que o interpretador Python está instalado na sua máquina. Se você utiliza o Mac OS X, Linux ou outro sistema tipo o Unix então a resposta é provavelmente sim, pois esses sistemas constumam vir com o Python pré-instalado. Se você utiliza o Windows é quase certo que você não tem o interpretador. Para verificar, abra um terminal e digite o comando {{{python -V}}}, uma típica resposta será

{{{
Dharma:~ ruda$ python -V
Python 2.5
}}}

indicando que eu tenho instalado a versão 2.5 da linguagem Python.

Se você tem o Windows é um bom momento para baixar o instalador da linguagem Python, que pode ser obtido em http://www.python.org/ftp/python/2.5.2/python-2.5.2.msi

== Primeiras Idéias ==
Linha 105: Linha 34:
Python não é compilada, mas sim interpretada, assim como PHP, Perl e muitas outras, ou seja, não há o processo de compilação. O que acontece é que o código-fonte (ou script) é "traduzido" direto, através de um interpretador (imagine que ele é um intérprete mesmo, pois é assim que funciona!). Observação: Geralmente, quando uma linguagem é interpretada, existe um código intermediário (''bytecode''), com o qual o programador não precisa se preocupar. Seria muito lento interpretar diretamente o texto do código fonte. No caso do Python, o ''bytecode'' é salvo em arquivos '''.pyc''' e '''.pyo'''.

Tal fato adiciona muita produtividade à linguagem, já que o processo de programar é somente escrever-rodar, ao contrário de escrever-compilar-rodar. Veja que o ciclo dum programa interpretado é bem mais eficiente, pois a fase de testes é MUITO simplificada:
Python não é compilada, mas sim interpretada, assim como PHP, Perl e muitas outras, ou seja, não há o processo de compilação. O que acontece é que o código-fonte (ou script) é "traduzido" direto, através de um interpretador (imagine que ele é um intérprete mesmo, pois é assim que funciona!). Observação: Geralmente, quando uma linguagem é interpretada, existe um código intermediário (''bytecode''), com o qual o programador não precisa se preocupar. Seria muito lento interpretar diretamente o texto do código fonte. No caso do Python, o ''bytecode'' é salvo em arquivos '''.pyc''' e '''.pyo''' (''bytecode'' otimizado)

Tal fato adiciona muita produtividade à linguagem, já que o processo de programar é somente escrever-rodar, ao contrário de escrever-compilar-rodar. Veja que o ciclo de um programa interpretado é bem mais eficiente, pois a fase de testes é MUITO simplificada:
Linha 111: Linha 40:
C: escrever-compilar-testar-corrigir-compilar-testar-distribuir Linguagem C: escrever-compilar-testar-corrigir-compilar-testar-distribuir
Linha 123: Linha 52:
== Modo interativo ==

O Python também pode ser usado em modo interativo. Para isso, basta digitar '''python'''. E deve aparecer algo parecido com isso:

{{{
Python 2.5.2 (r252:60911, Apr 21 2008, 11:12:42)
[GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
}}}

Em modo interativo, o Python executa o que voce digitar imediatamente (ou quase...), o que é muito bom para testes e para aprender.

O sinal '''>>>''' é o ''prompt'' padrão Python. Significa que ele está de prontidão esperando um comando. Se o comando tiver algum resultado, este será mostrado na tela.

Para sair, aperte Control + D (nos UNIXes) ou Control + Z seguido de Enter (no Windows)
Linha 125: Linha 71:
  Python é dinamicamente tipado, o que significa que se você usou uma variável para armazenar um inteiro, nada lhe impede de usá-la posteriormente para armazenar uma string (frase). Na verdade, variáveis em Python não são declaradas, o que lhe dá muita flexibilidade.

  Quem determina o tipo de uma variável é o próprio interpretador. Se você escreve:
Python é dinamicamente tipado, o que significa que se você usou uma variável para armazenar um inteiro, nada lhe impede de usá-la posteriormente para armazenar uma string (frase). Na verdade, variáveis em Python não são declaradas, o que lhe dá muita flexibilidade.

Quem determina o tipo de uma variável é o próprio interpretador. Se você escreve:
Linha 143: Linha 89:
 Como x já disse, tudo mudou, e isso é bem natural. Na verdade, raras são as vezes em que você precisa se preocupar com tipos. Geralmente você simplesmente atribui um valor a uma variável e pronto! Isso é bem simples. Mas não abuse desse recurso, senão seus programas vão virar uma confusão.

 Então aqui vão alguns exemplos de tipos:

{{{
#!python
x = 2 #inteiro

p = 3.1415 #real, ou ponto flutuante

estringue = 'alguma frase' #string

lista = [3, 4, 5] #lista com elementos inteiros

lista2 = [2,'tres',4.0,[5,6]] #lista mista e aninhada

tupla = (1,2,3,'quatro') #isso se chama tupla. É como uma lista, mas não pode ser mudada
Como x já disse, tudo mudou, e isso é bem natural. Na verdade, raras são as vezes em que você precisa se preocupar com tipos. Geralmente você simplesmente atribui um valor a uma variável e pronto! Isso é bem simples. Mas não abuse desse recurso, senão seus programas vão virar uma confusão.

Então aqui vão alguns exemplos de tipos:

{{{
#!python
x = 2                   # Inteiro

p = 3.1415                   # Real, ou ponto flutuante

verdadeiro = True # Boolean

estringue = 'alguma frase'    # String

c = 3 + 2j # Complexo


lista = [3, 4, 5]             # Lista com elementos inteiros

lista2 = [2,'tres',4.0,[5,6]] # Lista mista e aninhada

tupla = (1,2,3,'quatro')     # Tupla. É como uma lista, mas não pode ser mudada
Linha 168: Linha 118:
Linha 172: Linha 123:
dic = {'site':'Python Brasil','url':'www.pythonbrasil.com.br'} # isso é um dicionário dic = {'site':'Python Brasil','url':'www.pythonbrasil.com.br'} # Isso é um dicionário
Linha 176: Linha 127:
Linha 184: Linha 136:
    * decimal ''(proposto, ainda não faz parte do Python)'' (Números fracionários representados de forma decimal em vez de binária)

=== Tipos agrupados (listas, tuplas, dicionários) ===
    * list
    * tuple
    * dict
    * decimal ''(integrado ao Python 2.4 como módulo)'' (Números fracionários representados de forma decimal em vez de binária)

=== Tipos agrupados ===

    * list (listas)
    * tuple (tuplas - listas imutáveis)
    * dict (dicionários)
    * set (novo tipo incluso no Python 2.4 - uma lista sem repetições)

=== Tipos mutáveis e imutáveis ===

Alguns tipos no Python permitem que elementos que fazem parte de sua estrutura sejam modificados, como as listas e dicionários. Estes tipos são chamados '''mutáveis'''.

Exemplo:

{{{
#!python

>>> l = ['Nirvana', 'Rush', 'Bauhaus']
>>> l[1] = 'Who'
>>> l
['Nirvana', 'Who', 'Bauhaus']
>>>

}}}

Outros tipos não permitem isso, como tuplas e strings. Estes são chamados '''imutáveis'''.

Exemplo:

{{{
#!python

>>> s = 'MYSQL'
>>> s[1] = 'y'
Traceback (most recent call last):
  File "<stdin>", line 1, in
TypeError: object does not support item assignment

}}}

=== Listas ===

O tipo lista do Python é bastante sofisticado e flexível. Como classe, a lista conta com métodos para ordenar (sort), inverter (reverse), contar ocorrências de um determinado elemento (count) e outros.

{{{
#!python

>>> # Criando a lista de bandas
...
>>> lista = ['Led Zeppelin', 'King Crimson', 'Yes', 'The Who', 'Pink Floyd']
>>>
>>> # Acessando um ítem da lista
...
>>> lista[0]
'Led Zeppelin'
>>>
>>> # Para elementos de listas dentro de listas ou caracteres de strings dentro de listas
...
>>> lista[0][0]
'L'
>>>
>>> # Retornando uma parte da lista (do terceiro até o quarto ítem)
...
>>> lista[2:4]
['Yes', 'The Who']
>>>
>>> # Retornando uma parte da lista (do segundo até o fim)
...
>>> lista[1:]
['King Crimson', 'Yes', 'The Who', 'Pink Floyd']
>>>
>>> # Retornando uma parte da lista (a partir do inicio até penúltimo)
...
>>> lista[:-1]
['Led Zeppelin', 'King Crimson', 'Yes', 'The Who']
>>>
>>> # acessando a lista em passos
...
>>> lista[::2]
['Led Zeppelin', 'Yes', 'Pink Floyd']
>>>
>>> # Passo negativo
...
>>> lista[::-1]
['Pink Floyd', 'The Who', 'Yes', 'King Crimson', 'Led Zeppelin']
>>>
>>> # Convertendo para uma string
...
>>> ', '.join(lista)
'Led Zeppelin, King Crimson, Yes, The Who, Pink Floyd'
>>>
>>> # Contando ocorrências
...
>>> lista.count('Yes')
1
>>>
}}}
Linha 192: Linha 236:
    * if...elif...else

Estruturas if elif else

O if o elif e o else servem para examinar expressões. Em português eles avaliam se determinada expressão retorna Verdadeiro ou Falso.

Em Python os valores mais vazios: None, [] (* Lista vazia), "", 0. São tidos como Falso. E os outros valores são verdadeiros.

Explicado isso vamos aos exemplos:

*IF*

Obs: Os exemplos são digitados no Python Interativo.

As estruturas condicionais disponíveis no Python são '''if''', '''elif''' e '''else'''.

O '''if''', o '''elif''' e o '''else''' servem para examinar expressões. À grosso modo, pode-se dizer que eles avaliam se determinada expressão retorna Verdadeiro (True) ou Falso (False).

Em Python os valores vazios: None, [] (* Lista vazia), "", 0. São tidos como Falso (False). E os outros valores são verdadeiros (True).

Explicado isso, vamos às explicações:

=== if ===

Antes uma breve explicação do que vem a ser '''if'''. Como é sabido, '''if''' é traduzido em português para "se". Nas linguagens de programação esse "se" ('''if''') atua como um verificador de condições, algo como:
    
{{{
se ( essa condição for verdadeira ):
    esse bloco de comandos
    será executado
}}}

Traduzindo em um exemplo bobo em Python, teriamos:
    
{{{
#!python
if (10 > 5):
    print "10 é maior do que 5"
}}}

No caso, o bloco (composto apenas por um comando, no caso) seria sempre executado. Os parênteses na "condição" são opcionais.

Vamos a outros exemplos.

Obs: Os exemplos são do modo interativo ('''shell''') do Python.
    
Linha 208: Linha 272:
In [1]: meuNome = "Ruivaldo"
In [1]: meuNome = "Juares"
Linha 211: Linha 274:
Linha 213: Linha 275:
   ...: print "Nos temos os nomes iguais!"    ...: print "Nos temos os nomes iguais"
Linha 217: Linha 279:
Você notou que o print não ocorreu já que as variáveis meuNome e seuNome são diferentes.

Agora observe esse exemplo:
Você notou que o '''print''' não ocorreu, já que as variáveis meuNome e seuNome são diferentes. Na linha 3 o '''if''' verifica essa igualdade, mas como o valor retornado da verificação é falso, ele não executa o comando print.


Agora observe esse outro exemplo:
Linha 224: Linha 288:
Linha 226: Linha 289:

In [3]: if meuNome == se
setattr seuNome

In [3]: if meuNome == se
setattr seuNome
Linha 234: Linha 290:
   ...: print "Temos os nomes iguais!"    ...: print "Temos os nomes iguais"
Linha 236: Linha 292:
Temos os nomes iguais!
}}}

Viu ? Agora imprimiu, já que as variáveis são iguais.

*ELSE*

Vamos dar uma olhada no ELSE agora. Vejamos esse exemplo:
Temos os nomes iguais
}}}

Viu? Agora imprimiu, já que as variáveis são iguais. O '''if''', novamente na linha 3, fez a verificação de igualdade ('''==''') e obteve resultado Verdadeiro ('''True'''), logo executou o comando '''print'''.

=== else ===

Se o '''if''' refere-se ao "se", quando traduzido, o '''else''' refere-se ao "senão". Exemplificando:

{{{
se ( condição for verdadeira ):
    execute esses comandos
    esse também
senão:
    execute
    esses comandos
}}}

No caso o "se" é o '''if''' e o "senão" o '''else'''. Note que o '''else''' é executado se o '''if''' não for executado, ou seja, a condição do '''if''' não foi atendida. Caso o '''if''' tenha sido executado, o '''else''' não é executado.

Vamos a um exemplo em código Python:
    
Obs: Estes códigos também são exemplos do '''shell''' do Python.
    
Linha 247: Linha 319:
In [1]: meuNome = "Ruivaldo"

In [2]:
seuNome = "Adolfo"

In [3]: if m
map max meuNome min

In [3]:
if meuNome == se
setattr seuNome

In [3]
: if meuNome == seuNome:
   ...: print "Temos nomes iguais!"
   ...: else:
   ...: print "Nossos nomes sao diferentes... :("
   ...:
Nossos nomes sao diferentes... :(

}}}

O else não verifica nada. Ele é só uma delimitação de código a ser executado caso o if não ocorra.

Mais um exemplo só para fixar:
>>> meuNome = "Ruivaldo"
>>> seuNome = "Adolfo"
>>> if meuNome == seuNome:
... print "Temos nomes iguais"
... els
e:
... print "Nossos nomes sao diferentes"
...
Nossos nomes sao diferentes

}}}

Reiterando. O '''else''' não verifica nada. Ele é só uma delimitação de código a ser executado caso o '''if''' não ocorra.

Mais um exemplo, só para fixar:
Linha 271: Linha 336:
In [1]: x = 5

In [2]:
y = 10

In [3]:
if x > 5:
   ...: print "X maior que Y"
   ...: else:
   ...: print "Y maior ou igual a X"
   ...:
>>> x = 5
>>> y = 10
>>> if x > 5:
... print "X maior que Y"
... else:
... print "Y maior ou igual a X"
...
Linha 283: Linha 346:
Nesse exemplo nós não sabemos se o Y é igual ao X. Teríamos que usar o ELIF, que eu vou explicar agora.

*ELIF*

O elif é uma mistura de if com else. Calma, não se assuste. Ele é um else, logo só é executado se o if não ocorrer, só que além de else ele também é um if, então pro bloco elif ser executado a sua expressão tem que ser verdadeira.
Nesse exemplo nós não sabemos quando o Y é igual ao X. Teríamos que usar o '''elif''', que veremos agora.

=== elif ===

O '''elif''' é uma mistura de '''if''' com '''else'''. Calma, não se assuste. Ele é um '''else''', logo só é executado se o '''if''' não ocorrer, só que além de '''else''' ele também é um '''if''', então pro bloco '''elif''' ser executado além do primeiro '''if''' não ser executado, deve-se atender a uma determinada condição.

Em portugol seria algo como:
{{{
se ( condição ):
    executa comando
    comando
se-if-não-foi-executado-e ( condição ):
    executa comando
    comando
senão:
    comando comando
    comando
}}}

Como já foi dito: o "se" é o '''if''', o "se-if-não-foi-executado-e" é o '''elif''' e o "senão" é o '''else'''.
Linha 290: Linha 368:
Linha 293: Linha 372:
In [1]: x = 5

In [2]:
y = 10

In [3]:
if x > y:
   ...: print "X maior que Y"
   ...: elif x == y:
   ...: print "X igual a Y"
   ...: else:
   ...: print "Y maior que X"
   ...:
>>> x = 5
>>> y = 10
>>> if x > y:
... print "X maior que Y"
... elif x == y:
... print "X igual a Y"
... else:
... print "Y maior que X"
...
Linha 306: Linha 383:
Note que agora se o x for igual ao y ele irá imprimir uma mensagem. Veja esse mais outro exemplo:
Note que agora se o x for igual ao y ele irá imprimir uma mensagem. Veja esse outro exemplo:
    
Linha 310: Linha 389:
In [1]: x = 5

In [2]:
y = 5

In [3]:
if x > y:
   ...: print "X > Y"
   ...: elif x == y:
   ...: print "X == Y"
   ...: else:
   ...: print "X < Y"
   ...:
>>> x = 5
>>> y = 5
>>> if x > y:
... print "X > Y"
... elif x == y:
... print "X == Y"
... else:
... print "X < Y"
...
Linha 324: Linha 401:
Pronto. Provado o que eu te falei.

*Modificador not*

O modificador not é uma palavrinha que serve pra negar a expressão do if ou elif. Ao invés de esperar o valor verdadeiro da expressão o if vai esperar pelo valor negativo. Veja mais esse exemplo:
Pronto. Estude os códigos, o conceito do '''elif''' é um pouco estranho mesmo, mas um pouco de estudo é o suficiente para dominá-lo.

=== Modificador not ===

O modificador '''not''' é uma palavrinha que serve pra negar a expressão do '''if''' ou '''elif'''. Ao invés de esperar o valor verdadeiro da expressão ,o '''if''' vai esperar pelo valor falso. Estudemos-o por um exemplo:
    
Linha 332: Linha 410:
In [1]: x = 5

In [2]:
y = 6

In [3]:
if not x == y:
   ...: print "X eh diferente de Y"
   ...:
>>> x = 5
>>> y = 6
>>> if not x == y:
... print "X eh diferente de Y"
...
Linha 342: Linha 418:
*Tabela de expressões válidas*

Você pode usar os seguintes símbolos em suas expressões if, elif:

===
Tabela de expressões válidas ===

Você pode usar os seguintes símbolos em suas expressões '''if''', '''elif''':
Linha 351: Linha 429:
!= (Diferente) = (Diferente)
Linha 355: Linha 433:
E para finalizar o in:


* Modificador in *

O in verifica se um elemento está dentro de outro.

Veja esses exemplos:
{{{
#!python
In [1]: if 1 in [1,2,3]: print "Esta!"
   ...:
Esta!

In [2]: if 'a' in "aloha":
   ...: print "Esta tambem"
   ...:
 E para finalizar essa seção do tutorial, o modificador in.
 
=== Modificador in ===

O '''in''' verifica se um elemento está dentro de outro. É como o símbolo de contido da matemática. Em portugol seria algo:
    
{{{
se elemento está-contido-em elemento-listável:
    comando
    comando
}}}

Traduzindo. O "se" está para o '''if''' e o "está-contido-em" para o modificador '''in'''. Porém temos ali um "elemento-listável". Meio estranho esse termo. Calma. Existem cinco tipos de elementos listáveis em Python: dicionários, listas, tuplas, strings (que são no fundo listas de caracteres) sets.

Isto é, no lugar de elemento-listável só pode haver uma variável dos tipos acima.

Vejamos esses exemplos:

{{{
#!python
>>> if 1 in [1,2,3]: print "Esta"
...
Esta
>>> if 'a' in "aloha":
... print "Esta tambem"
...
Linha 373: Linha 460:

In [3]: if [2,3] in [1,2,3]:
   ...: print "Esta"
   ...:

In [4]: if [2,3] in [[2,3],[2,4]]:
   ...: print "Esta denovo..."
   ...:
Esta denovo...

}}}
>>> if [2,3] in [1,2,3]:
... print "Esta"
...
>>> if [2,3] in [[2,3],[2,4]]:
... print "Esta denovo"
...
Esta denovo
}}}

Conselho: Para fixar os conceitos copie e execute todos os exemplos no '''shell''' do Python, assim você aprenderá.
Linha 387: Linha 472:
    * for
    
     Usando for:
     
Se você programa em C, vai perceber que o {{{for}}} em Python é diferente. Ele itera sobre listas. Por exemplo:

===
for ===
    
Se você programa em C, vai perceber que o {{{for}}} em Python é diferente. Ele itera sobre listas. Por exemplo:
Linha 399: Linha 484:
   Ou seja, para cada elemento da lista, itere. Você terá acesso ao item corrente ({{{print membro}}}). Se quiser fazer iterações sobre progressões aritméticas, use a função {{{range}}}, que cria uma lista de inteiro em seqüência. Exemplo: Ou seja, para cada elemento da lista, itere. Você terá acesso ao item corrente ({{{print membro}}}). Se quiser fazer iterações sobre progressões aritméticas, use a função {{{range}}}, que cria uma lista de inteiro em seqüência. Exemplo:
Linha 407: Linha 492:
   Isso vai imprimir na tela os números de 0 a 49.

  * while

    O while é muito simples. Ver o exemplo já vai ajudar muito:
(((
Isso vai imprimir na tela os números de 0 a 49.

=== while ===

O '''while''' é muito simples. Ver o exemplo já vai ajudar muito:

{{{
Linha 417: Linha 503:
   opc = raw_input("Digite 0 para sair \n > ")
)))

    Veja, o laço vai continuar iterando até que o usuário digite 0 na hora que o programa perguntar. Simples. O while é literalmente um "enquanto ISSO faça AQUILO".
   opc = int(raw_input("Digite 0 para sair \n > "))
}}}

Veja, o laço vai continuar iterando até que o usuário digite 0 na hora que o programa perguntar. Simples. O '''while''' é literalmente um "enquanto ISSO faça AQUILO".

Tando o '''for''' quanto o '''while''' podem ser interrompidos por '''break''' (o '''loop''' termina). O comando '''continue''' interrompe a iteração corrente e passa para a próxima.

== Funções ==

Simplificando, uma função é um bloco de código que tem nome (pelo qual ele pode ser chamado), recebe paramêtros (opcional) e gera um resultado (opcional)

Exemplo:

{{{
#!python

def media(lista = [0]):
    return float(sum(lista)) / len(lista)

print media([1,2,3,4,5])

}}}

'''media''' é o nome da função. '''lista''' é o paramêtro da função (no caso de vários paramêtros, seus nomes devem ser separados por vírgula). '''[0]''' é o valor padrão para '''lista''' (opcional)

'''return''' termina a execução da função, retornando o resultado (opcional) e o controle para a rotina que a chamou.

== Arquivos ==

Trabalhar com arquivos no Python é bem fácil. Como o Python é uma linguagem orientada a objetos, um arquivo é um objeto da classe '''file'''.

Um arquivo pode ser aberto para leitura ('r', o padrão), escrita ('w') ou inclusão ('a') ou para ler e gravar no mesmo arquivo ('w+'). Se um arquivo já existir e for aberto apenas para escrita ('w'), ele será zerado.

{{{
#!python

# Um texto para teste...

texto = '''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.'''

# Salvando em um arquivo chamado "zen.txt"

f = file('zen.txt', 'w')
f.write(texto)
f.close()

# Posso fazer em uma única linha:

file('zen.txt', 'w').write(texto)

# Para ler o arquivo:

arq = file('zen.txt')

# Trazendo o texto de volta:

texto = arq.read()

# Se preferir uma lista contendo as linhas do arquivo

linhas = arq.readlines()

# Se movendo para o inicio do arquivo

arq.seek(0)

# Imprimindo as linhas do arquivo:

for linha in arq: print linha,

# Fechando o arquivo

arq.close()

}}}
Linha 424: Linha 586:
    * try - except
    * try - finally
    * try / except
    * try / finally

As sentenças '''try / except''' e '''try / finally''' são mutuamente excludentes, não podem misturadas (embora possam ser usadas uma no interior da outra)

A sentença '''try / except''' especifica um ou mais manipuladores de exceção. Caso não ocorra erros, nenhum manipulador será executado. Ainda é possível definir um '''else''' opcional que será executado quando nenhum erro ocorrer. Exemplo:

{{{
#!python
try:
    # Vou tentar fazer isso:
    x = 1/0
except ZeroDivisionError:
    # Se houver divisão por zero, farei isso:
    print 'Divisão por zero...'
else:
    # Senão...
    print 'Não ocorreu nenhum erro!'
}}}

A sentença '''try / finally''' especifica um manipulador de limpeza, que será executado sempre. Quando não ocorre erros, '''finally''' é executado. Quando ocorre um erro, a exceção é salva, '''finally''' é executado, e logo após a exceção salva é executada novamente. Exemplo:

{{{
#!python
try:
    x = 1/0
finally:
    print 'Tentando dividir um 1 por 0... Ops!'
}}}

Nesse caso, o '''traceback''' aparecerá na tela, depois da mensagem.

=== Raise ===

Com a sentença '''raise''', você pode provocar uma exceção, que ser pode tratada pelo código que chamou aquela parte do programa. Exemplo:

{{{
#!python
try:
    z, y = 1, 0
    if y == 0:
        raise ZeroDivisionError
    else:
        print '%d divido por %d é %d' % (z, y, z/y)
except ZeroDivisionError:
    print 'Divisão por zero...'
else:
    print 'ocorreu algo inesperado!'
}}}

Dica: '''raise SystemExit''' termina o programa.
Linha 429: Linha 640:
Uma das características que me surpreendeu foi a facilidade de criar módulos simples. Por exemplo, se você quer criar um módulo chamado ''funcoesuteis'', é só criar um arquivo chamado ''funcoesuteis.py'' no mesmo diretório do seu programa principal. Nesse arquivo, coloque todos os '''def'''s e '''class'''es que quiser. No programa que for usar esse módulo, é só colocar {{{import funcoesuteis}}} e usar as funções como {{{funcoesuteis.funcao1()}}}, {{{funcoesuteis.funcao2()}}}, etc. Se quiser poupar digitação, use a forma {{{from funcoesuteis import funcao1, funcao2}}} e chame as funções diretamente: {{{funcao1()}}}, {{{funcao2()}}}.

(Melhorar: exemplos mais completos, descrição menos concisa e mais fácil de seguir, talvez explicar packages).

=== Pequeno complemento: ===

Um módulo Python é como se fosse um pedaço de programa que você, como programador, decidiu que ficaria melhor separado do todo. Essa decisão geralmente é tomada sobre estruturas que são usadas em diversos programas. Isso facilita nossa vida, pois já não precisamos "copiar e colar" as coisas de um lado para outro.
Um módulo em Python não é nada mais que um arquivo .py com definições de funções e classes. É isso mesmo. Apenas um arquivo.

Para facilitar o entedimento vamos exemplificar.

Escrevemos o código do seguinte módulo (logicamente, para fins didáticos apenas):
    
{{{
#!python
# Exemplo de módulo
# Módulo matematica.py

def somar(a,b):
    """
    Funcao que soma dois numeros
    """
    return a+b
    
def subtrair(a,b):
    """
    Funcao que subtrai dois numeros
    """
    return a - b
    
def multiplicar(a,b):
    """
    Funcao que multiplica dois numeros
    """
    return a * b
    
def dividir(a,b):
    """
    Funcao que divide dois numeros
    """
    return a / b
}}}

Salvamos ele como ""matematica.py"".

Agora vamos escrever três exemplos de uso do módulo.

    * Importando o módulo inteiro
    
Vamos ao código:
    
{{{
#!python
import matematica

print matematica.somar(1,2)
print matematica.dividir(100,25)
}}}

Executando esse arquivo nós temos como resultado:
    
{{{
3
4
}}}

Note que ao importar o módulo inteiro é obrigatório usar o nome do módulo antes de suas funções, classes...
Esse tipo de import evita problemas de namespace.

    * Importando o que a gente quer do módulo
    
{{{
#!python
from matematica import somar, dividir

print somar(1,2)
print dividir(100,25)
}}}

O resultado é o mesmo do exemplo anterior:
    
{{{
3
4
}}}

A única diferença é que nós só importamos duas funções do módulo e não precisamos por "matematica" para chamá-los, ou seja, as duas funções importadas foram colocadas dentro do namespace do arquivo que está usando o módulo. Esse tipo de import é bom para módulos muito grandes em que só se use uma fcoisa ou poucas coisas dele, há um certo aumento de desempenho nesse caso e economia de memória.

     * Importando tudo do módulo (diferente de importar o módulo inteiro)
     
{{{
#!python
from matematica import *

print somar(1,2)
print dividir(100,25)
print subtrair(10,8)
}}}

O resultado será:
    
{{{
3
4
2
}}}

É como o primeiro tipo de import, ele pega tudo do módulo, todas funções, classes, enfim. A diferença é que usando o """from modulo import *""" eliminamos a necessidade de ficar digitando "matematica" toda vez que quisermos chamar algo do módulo.


Observações:

    * Os arquivos de exemplo de uso do módulo devem estar na mesma pasta do módulo.
    * Ao fazer módulos procure não deixá-lo tão grande. É uma boa prática de programação.

Adendo: Um módulo Python é como se fosse um pedaço de programa que você, como programador, decidiu que ficaria melhor separado do todo. Essa decisão geralmente é tomada sobre estruturas que são usadas em diversos programas. Isso facilita nossa vida, pois já não precisamos "copiar e colar" as coisas de um lado para outro.
Linha 437: Linha 750:

=== Módulos distribuídos com o Python ===

Com o Python, são distribuídos muitos módulos, para servem para diversos propósitos (antes escrever algo do zero, verifique se existe algo pronto nos módulos do Python)

Exemplos de módulos:

    * os - suporte para recursos do sistema operacional (exemplos: mudar o diretório corrente e deletar arquivo)
    * sys - rotinas que controlam o ambiente de execução do Python (exemplos: consultar o PYTHONPATH (lista de diretórios aonde o Python procura módulos) e encerrar o programa)
    * copy - copia de objetos
    * subprocess - rotinas para executar processos (incluso no Python 2.4)

== Packages ==

O '''Package''' é uma maneira estruturar o '''namespace''' dos módulos através da ''notação do ponto''. Por exemplo, '''web.forms''' é uma referência ao módulo '''forms''' que faz parte do package '''web'''.

Com packages, os autores de módulos não precisam se preocupar com a colisão de nomes.

Para criar um package:

    * Crie um diretório (que terá o nome do package);

    * Crie um arquivo (que pode estar vázio) chamado {{{__init__.py}}} dentro do diretório;

    * Coloque os módulos do package dentro do mesmo diretório.

Um módulo que faz parte de um package pode ser importado como {{{import package.modulo}}} ou {{{from package import modulo}}}.

Opcionalmente, o arquivo {{{__init__.py}}} pode inicializar uma lista chamada {{{__all__}}}, que contém quais módulos serão importados usando {{{from package import *}}}.
Linha 457: Linha 799:
A classe criada chama-se {{{Pessoa}}}. É costume nomear classes {{{DesteJeito}}} em vez de {{{deste_jeito}}}. Assim, fica fácil de distinguir as classes dos objetos, das variáveis, das funções, etc. Essa convenção de nomenclatura é usada em Java, Ruby, Python e em outras linguagens (já que os programadores acabam levando esse costume de uma linguagem pra outra). Voltando à classe {{{Pessoa}}}. Nela definimos duas funções (funções dentro classes geralmente são chamadas de ''métodos''). A função andar, sob um ponto de vista muito abstrato, faz "a pessoa andar", ou seja, altera os valores x e y de sua posição (faça de conta que também existe uma função pra desenhar a pessoa :-) ).
Perceba que eu não declarei nenhuma das variáveis. Classes servem mesmo é pra criar métodos (agrupar funções), e não tanto para criar estruturas de variáveis (apesar de classes em Python serem ótimos containers).
A função {{{__init__()}}} é especial: ela é chamada toda a vez que é criada uma nova instância da classe (obs.: '''instância de classe''' é o mesmo que '''objeto'''), por isso o nome init: ela inicializa o objeto, e é opcional.
O argumento self é obrigatório, e deve ser o primeiro da função. Perceba que foi usado self na definição das variáveis. Isso quer dizer que estamos mexendo nas variáveis do objeto (Repare no detalhe: fora da classe usamos o nome do objeto criado, no caso {{{eu}}}. Dentro da classe, o código serve pra qualquer objeto criado a partir dessa classe, e o primeiro argumento, o {{{self}}}, representa o objeto sendo usado.).
A classe criada chama-se {{{Pessoa}}}. É costume nomear classes {{{DesteJeito}}} em vez de {{{deste_jeito}}}. Assim, fica fácil de distinguir as classes dos objetos, das variáveis, das funções, etc. Essa convenção de nomenclatura é usada em Java, Ruby, Python e em outras linguagens (já que os programadores acabam levando esse costume de uma linguagem pra outra). Voltando à classe {{{Pessoa}}}.

Nela definimos duas funções (funções dentro classes geralmente são chamadas de ''métodos''). A função ''andar'', sob um ponto de vista muito abstrato, faz "a pessoa andar", ou seja, altera os valores x e y de sua posição (faça de conta que também existe uma função pra desenhar a pessoa :-) ). Perceba que eu não declarei nenhuma das variáveis. Classes servem mesmo é pra criar métodos (agrupar funções), e não tanto para criar estruturas de variáveis (apesar de classes em Python serem ótimos containers).

A função {{{__init__()}}} é especial: ela é chamada toda a vez que é criada uma nova instância da classe (obs.: '''instância de classe''' é o mesmo que '''objeto'''), por isso o nome '''init''': ela inicializa o objeto, e é opcional. O argumento '''self''' é obrigatório, e deve ser o primeiro da função. Perceba que foi usado '''self''' na definição das variáveis. Isso quer dizer que estamos mexendo nas variáveis do objeto (Repare no detalhe: fora da classe usamos o nome do objeto criado, no caso {{{eu}}}. Dentro da classe, o código serve pra qualquer objeto criado a partir dessa classe, e o primeiro argumento, o {{{self}}}, representa o objeto sendo usado.).
Linha 473: Linha 817:

O '''pass''' serve para indicar que nada precisa ser feito (porém a síntaxe exige que exista uma sentença naquele lugar)
Linha 499: Linha 845:
Herança é um recurso poderoso da programação orientada a objetos que permite reutilizar o código de classes já definidas. O Python suporta herança múltipla, ou seja, é possível criar uma nova classe a partir de várias outras (esse recurso deve ser usado com cuidado, pois isso dificulta a manutenção) Herança é um recurso poderoso da programação orientada a objetos que permite reutilizar o código de classes já definidas. Com a herança, é possível extender, especializar ou até mesmo fundir classes.

O Python suporta herança múltipla, ou seja, é possível criar uma nova classe a partir de várias outras (esse recurso deve ser usado com cuidado, pois isso pode criar dificuldades na manutenção)
Linha 507: Linha 855:
Linha 515: Linha 864:
# O nome da class 'mãe' (Na herança múltipla, os nomes das 'mães')
# é passado para a classe filha
Linha 525: Linha 877:
  def removerFaixa(self, numero, titulo):   def removerFaixa(self, numero, nome):
Linha 528: Linha 880:
# Criando objeto
Linha 529: Linha 883:

# Evocando métodos:
Linha 533: Linha 889:
# Listando a estrutura do objeto
Linha 534: Linha 892:

# Acesando atributos
Linha 536: Linha 897:

}}}
}}}

== Namespaces ==

Um '''Namespace''' é um dicionário com os nomes válidos em um programa durante a sua execução. Sendo assim, quando fazemos '''i = 1''', o nome '''i''' é colocado em um namespace. O nome pode ser localizado de duas formas:

    * Nome não qualificado

    * Nome qualificado

=== Nomes não qualificados ===

Quando o nome da variável não foi qualificado (exemplo: '''i = 0''', a busca é feita primeiro entre as variáveis locais (dica: para listar as variáveis locais: '''locals()'''), depois entre as variáveis globais (dica: para listar as variáveis globais: '''globals()''') e por fim entre as variáveis pré-definidas do Python ('''builtins'''. Exemplos: '''True''' e '''False''')

=== Nomes qualificados ===

Quando o nome da variável foi qualificado (exemplo: '''livro.pagina''', a busca é feita primeiro no objeto, depois na classe do objeto e segue a hierarquia de herança.

== List Comprehensions ==

'''List Comprehension''' é um nome pomposo para algo simples - uma construção que permite processar listas de uma forma bem próxima a matemática.

A sintaxe é [<expressão> for <variável> in <lista> if <condição>]

Aonde:

    * <lista> é a lista original a ser processada;

    * <variável> ítem da lista a ser processada;

    * <expressão> expressão a ser aplicada em cada ítem;

    * <condição> condição que deve ser cumprida para que o ítem seja processado.

A parte for <variável> in <lista> pode se repetir N vezes.

A condição é opcional.

Exemplo:


{{{
#!python
>>> # Multiplos de 4 entre 0 em 99:
...
>>> [x for x in range(100) if x % 4 == 0]
[0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96]
>>>
}}}

== Generators ==

Muitas vezes, em programação, é necessário processar listas de elementos. Porém, manter listas inteiras em memória, dependendo do tamanho, podem causar problemas de performance. Para isso, no Python, temos os Generators.

Na sintaxe, os generators são parecidos com as funções, porém existem algumas diferenças significativas:

    * Um objeto do tipo generator retorna um elemento de cada vez quando evocado (através do método '''next'''
    * O '''return''' habitual é substituido por '''yield'''
    * Como os elementos são gerados apenas quando (e se) necessário, o resultado é menos consumo de recursos (isto é chamado '''Lazy Evaluation''')

Exemplo:

{{{
#!python
>>> def getchar(word):
... for c in word:
... yield c
...
>>> pythonchars = getchar('Python')
>>> pythonchars
<generator object at 0x009D5EE0>
>>> pythonchars.next()
'P'
>>> pythonchars.next()
'y'
>>> pythonchars.next()
't'
>>> pythonchars.next()
'h'
>>> pythonchars.next()
'o'
>>> pythonchars.next()
'n'
>>>
}}}

=== Generator Expressions ===

Generator Expressions (também chamadas de ''Genexps'') são o equivalente a List Comprehensions para se criar Generators.

A sintaxe é semelhante a da List Comprehension, porém, numa Generator Expression se usa () (parantesis) para delimitar a expressão, ao invez de [] (colchetes) como na List Comprehension.

Uma Generator Expression pode ser vista também como a versão ''Lazy Evaluated'' da List Comprehension, já que cada elemento é gerado apenas quando necessario, e não todos de ''uma vez''.

Exemplo (baseado num [http://www.artima.com/forums/flat.jsp?forum=106&thread=98196 post] de Guido Van Rossum em seu blog):

{{{#!python
>>> # funções uteis para usar com genexps
>>> def any(S):
... for x in S:
... if x:
... return True
... return False
...
>>> def all(S):
... for x in S:
... if not x:
... return False
... return True
...
>>> S = [42, 42]
>>> # Usando Genexps
>>> any(x > 42 for x in S) # True se algum elemento de S for > 42
>>> all(x != 0 for x in S) # True se todos os elemtos de S forem diferentes de zero
}}}
Linha 547: Linha 1020:

(Po! Eu acho legal colocar o exemplo de quiz... ia simplificar muito o aprendizdo, visto que editar codigo eh um otimo aprendizado...)

(Acho que toolkits gráficos atrapalham para quem está aprendendo (até porque tem toneladas deles). Seria legal ter um tutorial só de tk com o programa completo. Pessoalmente, preferia que fosse PyGTK...)

(Eu tenho um pouco de experiencia com PyGTK, mas poderiamos fazer um no console tambêm. ~YuriSchlesner)

(Se esta página e´sobre uma introdução em Python nada mais justo que usar algo fraquinho como Tkinter. Andrik Machado Batista)

(Se Tkinter é fraquinho, portanto não muito útil, então porque não algo mais prático? Interface Web, por exemplo)

(Outra coisa - não seria melhor separar a página em partes? Ela está ficando um pouco grande...)

== Próximos passos ==

Existem muitos caminhos para continuar aprendendo Python. Algumas possibilidades são:

    * Esse próprio site ([http://www.pythonbrasil.com.br/ PythonBrasil])

    * A documentação oficial do Python, em inglês ([http://www.python.org/doc/2.4.1/ Python 2.4.1 Documentation])

TableOfContents

Guia de Introdução à Linguagem Python

Apresentação

Bem-vindo(a) ao nosso guia de introdução à linguagem Python. Este guia exige que se tenha noção de linguagens de programação e para isso é necessário saber o que são algoritmos e estruturas de dados. Quem já programou em uma outra linguagem, como Visual Basic, Delphi ou C poderá se sentir mais apto a programar em Python com esse guia.

Quem sabe você tem dúvidas conceituais sobre a linguagem. Se for este o seu caso, faça uma leitura na seção de [http://www.pythonbrasil.com.br/moin.cgi/PerguntasFrequentes/SobrePython Perguntas e Respostas freqüentes sobre Python].

Pronto para começar? Talvez não, porque é necessário ter certeza que o interpretador Python está instalado na sua máquina. Se você utiliza o Mac OS X, Linux ou outro sistema tipo o Unix então a resposta é provavelmente sim, pois esses sistemas constumam vir com o Python pré-instalado. Se você utiliza o Windows é quase certo que você não tem o interpretador. Para verificar, abra um terminal e digite o comando python -V, uma típica resposta será

Dharma:~ ruda$ python -V
Python 2.5

indicando que eu tenho instalado a versão 2.5 da linguagem Python.

Se você tem o Windows é um bom momento para baixar o instalador da linguagem Python, que pode ser obtido em http://www.python.org/ftp/python/2.5.2/python-2.5.2.msi

Primeiras Idéias

Se você NUNCA programou antes, é necessário entender alguns conceitos básicos.

Por exemplo: você sabe o que é um "executável" certo? Experimente abrir um arquivo desses em algum editor de textos. A não ser que você tenha vivido anos na Matrix, não entenderá nada!

Isso acontece porque o programa está escrito, ali, em linguagem de máquina, ou seja, apesar de você não entender nada, o computador entende muito bem.

Mas não pense que alguém escreveu aquilo do jeito que está. Também não foi escrito ao estilo "morse" (10010010110)... inicialmente, o programador escreveu o que chamamos de "código-fonte" em alguma linguagem de programação, como C, C++, Pascal, e, depois de terminado, compilou o código, ou seja, traduziu de C, C++, Pascal para linguagem de máquina (também chamada de Assembly).

Essas linguagens que eu citei acima são as linguagens compiladas, pois antes de serem executadas, seus códigos-fonte devem ser devidamente compilados.

Python não é compilada, mas sim interpretada, assim como PHP, Perl e muitas outras, ou seja, não há o processo de compilação. O que acontece é que o código-fonte (ou script) é "traduzido" direto, através de um interpretador (imagine que ele é um intérprete mesmo, pois é assim que funciona!). Observação: Geralmente, quando uma linguagem é interpretada, existe um código intermediário (bytecode), com o qual o programador não precisa se preocupar. Seria muito lento interpretar diretamente o texto do código fonte. No caso do Python, o bytecode é salvo em arquivos .pyc e .pyo (bytecode otimizado)

Tal fato adiciona muita produtividade à linguagem, já que o processo de programar é somente escrever-rodar, ao contrário de escrever-compilar-rodar. Veja que o ciclo de um programa interpretado é bem mais eficiente, pois a fase de testes é MUITO simplificada:

Python: escrever-testar-corrigir-escrever-testar-distribuir

Linguagem C: escrever-compilar-testar-corrigir-compilar-testar-distribuir

Tecnicamente, qualquer linguagem pode ser compilada ou interpretada, mas as linguagens mais dinâmicas geralmente são interpretadas e as mais estáticas (estilo declare-antes-de-usar) são compiladas.

Se você já tem um interpretador instalado em seu sistema, experimente escrever o seguinte script:

   1 print "Olá, mundo"
  • Depois, num terminal, digite "python nome_do_script", e veja como é simples!

Modo interativo

O Python também pode ser usado em modo interativo. Para isso, basta digitar python. E deve aparecer algo parecido com isso:

Python 2.5.2 (r252:60911, Apr 21 2008, 11:12:42) 
[GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 

Em modo interativo, o Python executa o que voce digitar imediatamente (ou quase...), o que é muito bom para testes e para aprender.

O sinal >>> é o prompt padrão Python. Significa que ele está de prontidão esperando um comando. Se o comando tiver algum resultado, este será mostrado na tela.

Para sair, aperte Control + D (nos UNIXes) ou Control + Z seguido de Enter (no Windows)

Tipos de dados, constantes, variáveis e expressões

Python é dinamicamente tipado, o que significa que se você usou uma variável para armazenar um inteiro, nada lhe impede de usá-la posteriormente para armazenar uma string (frase). Na verdade, variáveis em Python não são declaradas, o que lhe dá muita flexibilidade.

Quem determina o tipo de uma variável é o próprio interpretador. Se você escreve:

   1 x = 2
   2 FRASE = 'Isso é um exemplo simples e bobo'
  • O interpetador já sabe que x é um inteiro e FRASE é uma string. Mas isso não lhe impede de, posteriormente, escrever

   1 x = 'agora tudo mudou'
   2 FRASE = 3.2

Como x já disse, tudo mudou, e isso é bem natural. Na verdade, raras são as vezes em que você precisa se preocupar com tipos. Geralmente você simplesmente atribui um valor a uma variável e pronto! Isso é bem simples. Mas não abuse desse recurso, senão seus programas vão virar uma confusão.

Então aqui vão alguns exemplos de tipos:

   1 x = 2                           # Inteiro
   2 
   3 p = 3.1415                      # Real, ou ponto flutuante
   4 
   5 verdadeiro = True               # Boolean
   6 
   7 estringue = 'alguma frase'      # String
   8 
   9 c = 3 + 2j                      # Complexo
  10 
  11 lista = [3, 4, 5]               # Lista com elementos inteiros
  12 
  13 lista2 = [2,'tres',4.0,[5,6]]   # Lista mista e aninhada
  14 
  15 tupla = (1,2,3,'quatro')        # Tupla. É como uma lista, mas não pode ser mudada
  16 
  17 # tuplas de 0 ou 1 elementos têm sintaxes especiais:
  18 tupla0 = ()
  19 tupla1 = ('primeiro e único item',) # repare na vírgula
  20 
  21 # Em alguns casos (atribuições, returns), os parênteses são opcionais,
  22 # mas na maioria das vezes (tuplas dentro de listas, tuplas dentro de chamadas de funções)
  23 # os parênteses são necessários porque a vírgula faz parte de outra sintaxe
  24 
  25 coord = 4.5, 9.1
  26 cor_branca = 255, 255, 255 # cor no formato RGB
  27 funcao((4.5, 9.1), 'string')
  28 
  29 dic = {'site':'Python Brasil','url':'www.pythonbrasil.com.br'} # Isso é um dicionário

Tipos simples

  • str (Strings, como 'blabla')
  • unicode (São strs em que os caracteres podem representar qualquer língua, u'blabla')
  • bool (True ou False)
  • float (Números em ponto flutuante, como 4.5 ou 3.14e-10)
  • int (Números inteiros, como 99)
  • long (Números inteiros muito grandes, como 1234567890123456789123456789L)
  • complex (Números complexos, como 3.1j ou 7+3.14e-10j)
  • file (Arquivos)
  • decimal (integrado ao Python 2.4 como módulo) (Números fracionários representados de forma decimal em vez de binária)

Tipos agrupados

  • list (listas)
  • tuple (tuplas - listas imutáveis)
  • dict (dicionários)
  • set (novo tipo incluso no Python 2.4 - uma lista sem repetições)

Tipos mutáveis e imutáveis

Alguns tipos no Python permitem que elementos que fazem parte de sua estrutura sejam modificados, como as listas e dicionários. Estes tipos são chamados mutáveis.

Exemplo:

   1 >>> l = ['Nirvana', 'Rush', 'Bauhaus']
   2 >>> l[1] = 'Who'
   3 >>> l
   4 ['Nirvana', 'Who', 'Bauhaus']
   5 >>>

Outros tipos não permitem isso, como tuplas e strings. Estes são chamados imutáveis.

Exemplo:

   1 >>> s = 'MYSQL'
   2 >>> s[1] = 'y'
   3 Traceback (most recent call last):
   4   File "<stdin>", line 1, in 
   5 TypeError: object does not support item assignment

Listas

O tipo lista do Python é bastante sofisticado e flexível. Como classe, a lista conta com métodos para ordenar (sort), inverter (reverse), contar ocorrências de um determinado elemento (count) e outros.

   1 >>> # Criando a lista de bandas
   2 ...
   3 >>> lista = ['Led Zeppelin', 'King Crimson', 'Yes', 'The Who', 'Pink Floyd']
   4 >>>
   5 >>> # Acessando um ítem da lista
   6 ...
   7 >>> lista[0]
   8 'Led Zeppelin'
   9 >>>
  10 >>> # Para elementos de listas dentro de listas ou caracteres de strings dentro de listas
  11 ...
  12 >>> lista[0][0]
  13 'L'
  14 >>>
  15 >>> # Retornando uma parte da lista (do terceiro até o quarto ítem)
  16 ...
  17 >>> lista[2:4]
  18 ['Yes', 'The Who']
  19 >>>
  20 >>> # Retornando uma parte da lista (do segundo até o fim)
  21 ...
  22 >>> lista[1:]
  23 ['King Crimson', 'Yes', 'The Who', 'Pink Floyd']
  24 >>>
  25 >>> # Retornando uma parte da lista (a partir do inicio até penúltimo)
  26 ...
  27 >>> lista[:-1]
  28 ['Led Zeppelin', 'King Crimson', 'Yes', 'The Who']
  29 >>>
  30 >>> # acessando a lista em passos
  31 ...
  32 >>> lista[::2]
  33 ['Led Zeppelin', 'Yes', 'Pink Floyd']
  34 >>>
  35 >>> # Passo negativo
  36 ...
  37 >>> lista[::-1]
  38 ['Pink Floyd', 'The Who', 'Yes', 'King Crimson', 'Led Zeppelin']
  39 >>>
  40 >>> # Convertendo para uma string
  41 ...
  42 >>> ', '.join(lista)
  43 'Led Zeppelin, King Crimson, Yes, The Who, Pink Floyd'
  44 >>>
  45 >>> # Contando ocorrências
  46 ...
  47 >>> lista.count('Yes')
  48 1
  49 >>>

Estuturas de controle

As estruturas condicionais disponíveis no Python são if, elif e else.

O if, o elif e o else servem para examinar expressões. À grosso modo, pode-se dizer que eles avaliam se determinada expressão retorna Verdadeiro (True) ou Falso (False).

Em Python os valores vazios: None, [] (* Lista vazia), "", 0. São tidos como Falso (False). E os outros valores são verdadeiros (True).

Explicado isso, vamos às explicações:

if

Antes uma breve explicação do que vem a ser if. Como é sabido, if é traduzido em português para "se". Nas linguagens de programação esse "se" (if) atua como um verificador de condições, algo como:

se ( essa condição for verdadeira ):
    esse bloco de comandos
    será executado

Traduzindo em um exemplo bobo em Python, teriamos:

   1 if (10 > 5):
   2     print "10 é maior do que 5"

No caso, o bloco (composto apenas por um comando, no caso) seria sempre executado. Os parênteses na "condição" são opcionais.

Vamos a outros exemplos.

Obs: Os exemplos são do modo interativo (shell) do Python.

   1 # Exemplo IF 01
   2 In [1]: meuNome = "Juares"
   3 In [2]: seuNome = "Adolfo"
   4 In [3]: if meuNome == seuNome:
   5    ...:     print "Nos temos os nomes iguais"
   6    ...:

Você notou que o print não ocorreu, já que as variáveis meuNome e seuNome são diferentes. Na linha 3 o if verifica essa igualdade, mas como o valor retornado da verificação é falso, ele não executa o comando print.

Agora observe esse outro exemplo:

   1 # Exemplo IF 02
   2 In [1]: meuNome = "Adolfo"
   3 In [2]: seuNome = "Adolfo"
   4 In [3]: if meuNome == seuNome:
   5    ...:     print "Temos os nomes iguais"
   6    ...:
   7 Temos os nomes iguais

Viu? Agora imprimiu, já que as variáveis são iguais. O if, novamente na linha 3, fez a verificação de igualdade (==) e obteve resultado Verdadeiro (True), logo executou o comando print.

else

Se o if refere-se ao "se", quando traduzido, o else refere-se ao "senão". Exemplificando:

se ( condição for verdadeira ):
    execute esses comandos
    esse também
senão:
    execute
    esses comandos

No caso o "se" é o if e o "senão" o else. Note que o else é executado se o if não for executado, ou seja, a condição do if não foi atendida. Caso o if tenha sido executado, o else não é executado.

Vamos a um exemplo em código Python:

Obs: Estes códigos também são exemplos do shell do Python.

   1 #Exemplo ELSE 01
   2 >>> meuNome = "Ruivaldo"
   3 >>> seuNome = "Adolfo"
   4 >>> if meuNome == seuNome:
   5 ...     print "Temos nomes iguais"
   6 ... else:
   7 ...     print "Nossos nomes sao diferentes"
   8 ...
   9 Nossos nomes sao diferentes

Reiterando. O else não verifica nada. Ele é só uma delimitação de código a ser executado caso o if não ocorra.

Mais um exemplo, só para fixar:

   1 # Exemplo ELSE 02
   2 >>> x = 5
   3 >>> y = 10
   4 >>> if x > 5:
   5 ...     print "X maior que Y"
   6 ... else:
   7 ...     print "Y maior ou igual a X"
   8 ...
   9 Y maior ou igual a X

Nesse exemplo nós não sabemos quando o Y é igual ao X. Teríamos que usar o elif, que veremos agora.

elif

O elif é uma mistura de if com else. Calma, não se assuste. Ele é um else, logo só é executado se o if não ocorrer, só que além de else ele também é um if, então pro bloco elif ser executado além do primeiro if não ser executado, deve-se atender a uma determinada condição.

Em portugol seria algo como:

se ( condição ):
    executa comando
    comando
se-if-não-foi-executado-e ( condição ):
    executa comando
    comando
senão:
    comando comando
    comando

Como já foi dito: o "se" é o if, o "se-if-não-foi-executado-e" é o elif e o "senão" é o else.

Vamos a um exemplo similar ao anterior:

   1 #Exemplo ELIF 01
   2 >>> x = 5
   3 >>> y = 10
   4 >>> if x > y:
   5 ...     print "X maior que Y"
   6 ... elif x == y:
   7 ...     print "X igual a Y"
   8 ... else:
   9 ...     print "Y maior que X"
  10 ...
  11 Y maior que X

Note que agora se o x for igual ao y ele irá imprimir uma mensagem. Veja esse outro exemplo:

   1 # Exemplo ELIF 02
   2 >>> x = 5
   3 >>> y = 5
   4 >>> if x > y:
   5 ...     print "X > Y"
   6 ... elif x == y:
   7 ...     print "X == Y"
   8 ... else:
   9 ...     print "X < Y"
  10 ...
  11 X == Y

Pronto. Estude os códigos, o conceito do elif é um pouco estranho mesmo, mas um pouco de estudo é o suficiente para dominá-lo.

Modificador not

O modificador not é uma palavrinha que serve pra negar a expressão do if ou elif. Ao invés de esperar o valor verdadeiro da expressão ,o if vai esperar pelo valor falso. Estudemos-o por um exemplo:

   1 # Exemplo not
   2 >>> x = 5
   3 >>> y = 6
   4 >>> if not x == y:
   5 ...     print "X eh diferente de Y"
   6 ...
   7 X eh diferente de Y

Tabela de expressões válidas

Você pode usar os seguintes símbolos em suas expressões if, elif:

>= (Maior Igual)
> (Maior)
<= (Menor Igual)
< (Menor)
== (Igual)
= (Diferente)
<> (Diferente)
  • E para finalizar essa seção do tutorial, o modificador in.

Modificador in

O in verifica se um elemento está dentro de outro. É como o símbolo de contido da matemática. Em portugol seria algo:

se elemento está-contido-em elemento-listável:
    comando
    comando

Traduzindo. O "se" está para o if e o "está-contido-em" para o modificador in. Porém temos ali um "elemento-listável". Meio estranho esse termo. Calma. Existem cinco tipos de elementos listáveis em Python: dicionários, listas, tuplas, strings (que são no fundo listas de caracteres) sets.

Isto é, no lugar de elemento-listável só pode haver uma variável dos tipos acima.

Vejamos esses exemplos:

   1 >>> if 1 in [1,2,3]: print "Esta"
   2 ...
   3 Esta
   4 >>> if 'a' in "aloha":
   5 ...     print "Esta tambem"
   6 ...
   7 Esta tambem
   8 >>> if [2,3] in [1,2,3]:
   9 ...     print "Esta"
  10 ...
  11 >>> if [2,3] in [[2,3],[2,4]]:
  12 ...     print "Esta denovo"
  13 ...
  14 Esta denovo

Conselho: Para fixar os conceitos copie e execute todos os exemplos no shell do Python, assim você aprenderá.

Estruturas de iteração ou loop

for

Se você programa em C, vai perceber que o for em Python é diferente. Ele itera sobre listas. Por exemplo:

if not odeio_metallica:
    metallica = ['James','Kirk','Lars','Trujillo']
    for membro in metallica:
        print membro

Ou seja, para cada elemento da lista, itere. Você terá acesso ao item corrente (print membro). Se quiser fazer iterações sobre progressões aritméticas, use a função range, que cria uma lista de inteiro em seqüência. Exemplo:

   1 for i in range(50):
   2    print i

Isso vai imprimir na tela os números de 0 a 49.

while

O while é muito simples. Ver o exemplo já vai ajudar muito:

   1 opc = 1
   2 while opc != 0:
   3    # código e mais código...
   4    opc = int(raw_input("Digite 0 para sair \n > "))

Veja, o laço vai continuar iterando até que o usuário digite 0 na hora que o programa perguntar. Simples. O while é literalmente um "enquanto ISSO faça AQUILO".

Tando o for quanto o while podem ser interrompidos por break (o loop termina). O comando continue interrompe a iteração corrente e passa para a próxima.

Funções

Simplificando, uma função é um bloco de código que tem nome (pelo qual ele pode ser chamado), recebe paramêtros (opcional) e gera um resultado (opcional)

Exemplo:

   1 def media(lista = [0]):
   2     return float(sum(lista)) / len(lista)
   3 
   4 print media([1,2,3,4,5])

media é o nome da função. lista é o paramêtro da função (no caso de vários paramêtros, seus nomes devem ser separados por vírgula). [0] é o valor padrão para lista (opcional)

return termina a execução da função, retornando o resultado (opcional) e o controle para a rotina que a chamou.

Arquivos

Trabalhar com arquivos no Python é bem fácil. Como o Python é uma linguagem orientada a objetos, um arquivo é um objeto da classe file.

Um arquivo pode ser aberto para leitura ('r', o padrão), escrita ('w') ou inclusão ('a') ou para ler e gravar no mesmo arquivo ('w+'). Se um arquivo já existir e for aberto apenas para escrita ('w'), ele será zerado.

   1 # Um texto para teste...
   2 
   3 texto = '''Beautiful is better than ugly.
   4 Explicit is better than implicit.
   5 Simple is better than complex.
   6 Complex is better than complicated.
   7 Flat is better than nested.
   8 Sparse is better than dense.'''
   9 
  10 # Salvando em um arquivo chamado "zen.txt"
  11 
  12 f = file('zen.txt', 'w')
  13 f.write(texto)
  14 f.close()
  15 
  16 # Posso fazer em uma única linha:
  17 
  18 file('zen.txt', 'w').write(texto)
  19 
  20 # Para ler o arquivo:
  21 
  22 arq = file('zen.txt')
  23 
  24 # Trazendo o texto de volta:
  25 
  26 texto = arq.read()
  27 
  28 # Se preferir uma lista contendo as linhas do arquivo
  29 
  30 linhas = arq.readlines()
  31 
  32 # Se movendo para o inicio do arquivo
  33 
  34 arq.seek(0)
  35 
  36 # Imprimindo as linhas do arquivo:
  37 
  38 for linha in arq: print linha,
  39 
  40 # Fechando o arquivo
  41 
  42 arq.close()

Tratamento de erros e exceções

  • try / except
  • try / finally

As sentenças try / except e try / finally são mutuamente excludentes, não podem misturadas (embora possam ser usadas uma no interior da outra)

A sentença try / except especifica um ou mais manipuladores de exceção. Caso não ocorra erros, nenhum manipulador será executado. Ainda é possível definir um else opcional que será executado quando nenhum erro ocorrer. Exemplo:

   1 try:
   2     # Vou tentar fazer isso:
   3     x = 1/0
   4 except ZeroDivisionError:
   5     # Se houver divisão por zero, farei isso:
   6     print 'Divisão por zero...'
   7 else:
   8     # Senão...
   9     print 'Não ocorreu nenhum erro!'

A sentença try / finally especifica um manipulador de limpeza, que será executado sempre. Quando não ocorre erros, finally é executado. Quando ocorre um erro, a exceção é salva, finally é executado, e logo após a exceção salva é executada novamente. Exemplo:

   1 try:
   2     x = 1/0
   3 finally:
   4     print 'Tentando dividir um 1 por 0... Ops!'

Nesse caso, o traceback aparecerá na tela, depois da mensagem.

Raise

Com a sentença raise, você pode provocar uma exceção, que ser pode tratada pelo código que chamou aquela parte do programa. Exemplo:

   1 try:
   2     z, y = 1, 0
   3     if y == 0:
   4         raise ZeroDivisionError
   5     else:
   6         print '%d divido por %d é %d' % (z, y, z/y)
   7 except ZeroDivisionError:
   8     print 'Divisão por zero...'
   9 else:
  10     print 'ocorreu algo inesperado!'

Dica: raise SystemExit termina o programa.

Módulos

Um módulo em Python não é nada mais que um arquivo .py com definições de funções e classes. É isso mesmo. Apenas um arquivo.

Para facilitar o entedimento vamos exemplificar.

Escrevemos o código do seguinte módulo (logicamente, para fins didáticos apenas):

   1 # Exemplo de módulo
   2 # Módulo matematica.py
   3 
   4 def somar(a,b):
   5     """
   6     Funcao que soma dois numeros
   7     """
   8     return a+b
   9     
  10 def subtrair(a,b):
  11     """
  12     Funcao que subtrai dois numeros
  13     """
  14     return a - b
  15     
  16 def multiplicar(a,b):
  17     """
  18     Funcao que multiplica dois numeros
  19     """
  20     return a * b
  21     
  22 def dividir(a,b):
  23     """
  24     Funcao que divide dois numeros
  25     """
  26     return a / b

Salvamos ele como ""matematica.py"".

Agora vamos escrever três exemplos de uso do módulo.

  • Importando o módulo inteiro

Vamos ao código:

   1 import matematica
   2 
   3 print matematica.somar(1,2)
   4 print matematica.dividir(100,25)

Executando esse arquivo nós temos como resultado:

3
4

Note que ao importar o módulo inteiro é obrigatório usar o nome do módulo antes de suas funções, classes... Esse tipo de import evita problemas de namespace.

  • Importando o que a gente quer do módulo

   1 from matematica import somar, dividir
   2 
   3 print somar(1,2)
   4 print dividir(100,25)

O resultado é o mesmo do exemplo anterior:

3
4

A única diferença é que nós só importamos duas funções do módulo e não precisamos por "matematica" para chamá-los, ou seja, as duas funções importadas foram colocadas dentro do namespace do arquivo que está usando o módulo. Esse tipo de import é bom para módulos muito grandes em que só se use uma fcoisa ou poucas coisas dele, há um certo aumento de desempenho nesse caso e economia de memória.

  • Importando tudo do módulo (diferente de importar o módulo inteiro)

   1 from matematica import *
   2 
   3 print somar(1,2)
   4 print dividir(100,25)
   5 print subtrair(10,8)

O resultado será:

3
4
2

É como o primeiro tipo de import, ele pega tudo do módulo, todas funções, classes, enfim. A diferença é que usando o """from modulo import *""" eliminamos a necessidade de ficar digitando "matematica" toda vez que quisermos chamar algo do módulo.

Observações:

  • Os arquivos de exemplo de uso do módulo devem estar na mesma pasta do módulo.
  • Ao fazer módulos procure não deixá-lo tão grande. É uma boa prática de programação.

Adendo: Um módulo Python é como se fosse um pedaço de programa que você, como programador, decidiu que ficaria melhor separado do todo. Essa decisão geralmente é tomada sobre estruturas que são usadas em diversos programas. Isso facilita nossa vida, pois já não precisamos "copiar e colar" as coisas de um lado para outro. Claro, módulos podem ser mais complexos em certos pontos de vista. Eu mesmo não vejo nada de muita complexidade. Pura praticidade!

Módulos distribuídos com o Python

Com o Python, são distribuídos muitos módulos, para servem para diversos propósitos (antes escrever algo do zero, verifique se existe algo pronto nos módulos do Python)

Exemplos de módulos:

  • os - suporte para recursos do sistema operacional (exemplos: mudar o diretório corrente e deletar arquivo)
  • sys - rotinas que controlam o ambiente de execução do Python (exemplos: consultar o PYTHONPATH (lista de diretórios aonde o Python procura módulos) e encerrar o programa)
  • copy - copia de objetos
  • subprocess - rotinas para executar processos (incluso no Python 2.4)

Packages

O Package é uma maneira estruturar o namespace dos módulos através da notação do ponto. Por exemplo, web.forms é uma referência ao módulo forms que faz parte do package web.

Com packages, os autores de módulos não precisam se preocupar com a colisão de nomes.

Para criar um package:

  • Crie um diretório (que terá o nome do package);
  • Crie um arquivo (que pode estar vázio) chamado __init__.py dentro do diretório;

  • Coloque os módulos do package dentro do mesmo diretório.

Um módulo que faz parte de um package pode ser importado como import package.modulo ou from package import modulo.

Opcionalmente, o arquivo __init__.py pode inicializar uma lista chamada __all__, que contém quais módulos serão importados usando from package import *.

Classes

Criar uma classe em Python é muito simples. Acompanhe o exemplo:

   1 class Pessoa:
   2   def __init__(self):
   3     self.nome = ""
   4     self.x = 0
   5     self.y = 0
   6   def andar(self, x, y):
   7     self.y = self.y + y
   8     self.x = self.x + x
   9 
  10 eu = Pessoa()
  11 eu.nome = "Cléber"
  12 eu.andar(2, 0)

A classe criada chama-se Pessoa. É costume nomear classes DesteJeito em vez de deste_jeito. Assim, fica fácil de distinguir as classes dos objetos, das variáveis, das funções, etc. Essa convenção de nomenclatura é usada em Java, Ruby, Python e em outras linguagens (já que os programadores acabam levando esse costume de uma linguagem pra outra). Voltando à classe Pessoa.

Nela definimos duas funções (funções dentro classes geralmente são chamadas de métodos). A função andar, sob um ponto de vista muito abstrato, faz "a pessoa andar", ou seja, altera os valores x e y de sua posição (faça de conta que também existe uma função pra desenhar a pessoa :-) ). Perceba que eu não declarei nenhuma das variáveis. Classes servem mesmo é pra criar métodos (agrupar funções), e não tanto para criar estruturas de variáveis (apesar de classes em Python serem ótimos containers).

A função __init__() é especial: ela é chamada toda a vez que é criada uma nova instância da classe (obs.: instância de classe é o mesmo que objeto), por isso o nome init: ela inicializa o objeto, e é opcional. O argumento self é obrigatório, e deve ser o primeiro da função. Perceba que foi usado self na definição das variáveis. Isso quer dizer que estamos mexendo nas variáveis do objeto (Repare no detalhe: fora da classe usamos o nome do objeto criado, no caso eu. Dentro da classe, o código serve pra qualquer objeto criado a partir dessa classe, e o primeiro argumento, o self, representa o objeto sendo usado.).

Classes podem servir como os "struct" do C ou "record" do Pascal. dicts também podem servir como structs. dicts são mais usados pra simplesmente agrupar dados acessados por nome. Classes são mais usadas quando a estrutura é complexa, necessita de métodos de acesso e serão usadas várias instâncias da mesma estrutura. Pra simular uma struct, basta definir uma classe vazia, por exemplo:

   1 class conteiner:
   2    pass
   3 
   4 # E depois criar as variáveis dela "por fora",
   5 conteiner.var = "fácil, não?"
   6 conteiner.num = 1

O pass serve para indicar que nada precisa ser feito (porém a síntaxe exige que exista uma sentença naquele lugar)

Classes podem ser muito bem utilizadas, mas algumas vezes são péssimas opções. Assim como tudo em programação, saiba usá-las com parcimônia.

Exemplos, pra terminar:

   1 class Carro:
   2    def __init__(self, preco):
   3       self.marca = "Ford"
   4       self.modelo = "Maverick"
   5       self.ano = 74
   6       self.cor = [0,200,50]
   7       self.pos = [0,0]
   8    def andar(self, x, y):
   9       self.pos[0] = self.pos[0]+x
  10       self.pos[1] = self.pos[1]+y
  11 
  12 carango = Carro(5000)   #passa o valor 5000 para __init__()
  13 
  14 for i in range(300):
  15    carango.andar(1,0)  #o carro anda 300m

Herança

Herança é um recurso poderoso da programação orientada a objetos que permite reutilizar o código de classes já definidas. Com a herança, é possível extender, especializar ou até mesmo fundir classes.

O Python suporta herança múltipla, ou seja, é possível criar uma nova classe a partir de várias outras (esse recurso deve ser usado com cuidado, pois isso pode criar dificuldades na manutenção)

Exemplo:

   1 # definindo uma classe 'pai'
   2 
   3 class CD:
   4   def __init__(self, titulo):
   5     self.titulo = titulo
   6 
   7   def mudarTitulo(self, novoTitulo):
   8     self.titulo = novoTitulo
   9 
  10 # definindo uma classe 'filha'
  11 # O nome da class 'mãe' (Na herança múltipla, os nomes das 'mães')
  12 # é passado para a classe filha
  13 
  14 class CDAudio(CD):
  15 
  16   def __init__(self, titulo, autor):
  17     CD.__init__(self, titulo)
  18     self.autor = autor
  19     self.faixas = []
  20 
  21   def adicionarFaixa(self, numero, nome):
  22     self.faixas.append((numero, nome))
  23 
  24   def removerFaixa(self, numero, nome):
  25     self.faixas.remove((numero, nome))
  26 
  27 # Criando objeto
  28 
  29 novoCD = CDAudio('Physical Graphitte', 'Led Zeppelin');
  30 
  31 # Evocando métodos:
  32 
  33 novoCD.adicionarFaixa(1,'Custard Pie')
  34 novoCD.adicionarFaixa(2,'The Rover')
  35 
  36 # Listando a estrutura do objeto
  37 
  38 print dir(novoCD)
  39 
  40 # Acesando atributos
  41 
  42 print "CD: %s, %s" % (novoCD.titulo, novoCD.autor)
  43 print novoCD.faixas

Namespaces

Um Namespace é um dicionário com os nomes válidos em um programa durante a sua execução. Sendo assim, quando fazemos i = 1, o nome i é colocado em um namespace. O nome pode ser localizado de duas formas:

  • Nome não qualificado
  • Nome qualificado

Nomes não qualificados

Quando o nome da variável não foi qualificado (exemplo: i = 0, a busca é feita primeiro entre as variáveis locais (dica: para listar as variáveis locais: locals()), depois entre as variáveis globais (dica: para listar as variáveis globais: globals()) e por fim entre as variáveis pré-definidas do Python (builtins. Exemplos: True e False)

Nomes qualificados

Quando o nome da variável foi qualificado (exemplo: livro.pagina, a busca é feita primeiro no objeto, depois na classe do objeto e segue a hierarquia de herança.

List Comprehensions

List Comprehension é um nome pomposo para algo simples - uma construção que permite processar listas de uma forma bem próxima a matemática.

A sintaxe é [<expressão> for <variável> in <lista> if <condição>]

Aonde:

  • <lista> é a lista original a ser processada;

  • <variável> ítem da lista a ser processada;

  • <expressão> expressão a ser aplicada em cada ítem;

  • <condição> condição que deve ser cumprida para que o ítem seja processado.

A parte for <variável> in <lista> pode se repetir N vezes.

A condição é opcional.

Exemplo:

   1 >>> # Multiplos de 4 entre 0 em 99:
   2 ...
   3 >>> [x for x in range(100) if x % 4 == 0]
   4 [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96]
   5 >>>

Generators

Muitas vezes, em programação, é necessário processar listas de elementos. Porém, manter listas inteiras em memória, dependendo do tamanho, podem causar problemas de performance. Para isso, no Python, temos os Generators.

Na sintaxe, os generators são parecidos com as funções, porém existem algumas diferenças significativas:

  • Um objeto do tipo generator retorna um elemento de cada vez quando evocado (através do método next

  • O return habitual é substituido por yield

  • Como os elementos são gerados apenas quando (e se) necessário, o resultado é menos consumo de recursos (isto é chamado Lazy Evaluation)

Exemplo:

   1 >>> def getchar(word):
   2 ...     for c in word:
   3 ...         yield c
   4 ...
   5 >>> pythonchars = getchar('Python')
   6 >>> pythonchars
   7 <generator object at 0x009D5EE0>
   8 >>> pythonchars.next()
   9 'P'
  10 >>> pythonchars.next()
  11 'y'
  12 >>> pythonchars.next()
  13 't'
  14 >>> pythonchars.next()
  15 'h'
  16 >>> pythonchars.next()
  17 'o'
  18 >>> pythonchars.next()
  19 'n'
  20 >>>

Generator Expressions

Generator Expressions (também chamadas de Genexps) são o equivalente a List Comprehensions para se criar Generators.

A sintaxe é semelhante a da List Comprehension, porém, numa Generator Expression se usa () (parantesis) para delimitar a expressão, ao invez de [] (colchetes) como na List Comprehension.

Uma Generator Expression pode ser vista também como a versão Lazy Evaluated da List Comprehension, já que cada elemento é gerado apenas quando necessario, e não todos de uma vez.

Exemplo (baseado num [http://www.artima.com/forums/flat.jsp?forum=106&thread=98196 post] de Guido Van Rossum em seu blog):

   1 >>> # funções uteis para usar com genexps
   2 >>> def any(S):
   3 ...    for x in S:
   4 ...         if x:
   5 ...            return True
   6 ...    return False
   7 ...
   8 >>> def all(S):
   9 ...     for x in S:
  10 ...         if not x:
  11 ...            return False
  12 ...     return True
  13 ...
  14 >>> S = [42, 42]
  15 >>> # Usando Genexps
  16 >>> any(x > 42 for x in S)     # True se algum elemento de S for > 42
  17 >>> all(x != 0 for x in S)     # True se todos os elemtos de S forem diferentes de zero

Um exemplo Completo

Pretendo deixar um aplicativo de exemplo para sintetizar tudo. Uma idéia que me ocorreu agora é fazer um programinha gráfico (usando tk) de perguntas e repostas (quiz). Não sei se é confundir muito botar tk no meio, mas creio que se a pessoa entendeu o tutorial vai ser capaz de entender um pouco do código, mesmo porque com o quiz eu posso usar dicionários, listas, abrir/fechar arquivos (aka usar módulos), talvez usar classes e mostrar um exemplo prático que teoricamente rodaria em todas as plataformas.

(Sugestão: Coloca o programa sim! Assim o tutorial "cresce" junto com o leitor, em vez de ficar só no conhecimento básico - tem é que mergulhar fundo! Ao infinito e além!!)

(Muito bom! Este exemplo completo seria muito interessante. De repente não utilizar a biblioteca gráfica, para não complicar, tendo em vista que a sintaxe do Python é bem particular, não tendo muitas semelhanças com as linguagens de uso corriqueiro)

(Po! Eu acho legal colocar o exemplo de quiz... ia simplificar muito o aprendizdo, visto que editar codigo eh um otimo aprendizado...)

(Acho que toolkits gráficos atrapalham para quem está aprendendo (até porque tem toneladas deles). Seria legal ter um tutorial só de tk com o programa completo. Pessoalmente, preferia que fosse PyGTK...)

(Eu tenho um pouco de experiencia com PyGTK, mas poderiamos fazer um no console tambêm. ~YuriSchlesner)

(Se esta página e´sobre uma introdução em Python nada mais justo que usar algo fraquinho como Tkinter. Andrik Machado Batista)

(Se Tkinter é fraquinho, portanto não muito útil, então porque não algo mais prático? Interface Web, por exemplo)

(Outra coisa - não seria melhor separar a página em partes? Ela está ficando um pouco grande...)

Próximos passos

Existem muitos caminhos para continuar aprendendo Python. Algumas possibilidades são: