Treinamentos Zope, Plone e Python na Simples Consultoria  

IntroPython

  1. Guia de Introdução à Linguagem Python
      1. O que é Python
    1. O que eu posso fazer com Python?
    2. O que eu não posso fazer com Python?
    3. Por que eu deveria usar Python e não Perl, Java ou outra linguagem?
    4. De onde eu adquiro o Python?
      1. Linux
      2. Windows
      3. Macintosh
    5. Entendendo Python
    6. Tipos de dados, constantes, variáveis e expressões
      1. Tipos simples
      2. Tipos agrupados (listas, tuplas, dicionários)
      3. Mais sobre listas
    7. Estuturas de controle
    8. Estruturas de iteração ou loop
    9. Tratamento de erros e exceções
      1. Raise
    10. Módulos
      1. Pequeno complemento:
    11. Packages
    12. Classes
    13. Herança
    14. Namespaces
    15. List Comprehensions
    16. Um exemplo Completo

Guia de Introdução à Linguagem Python

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:

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

Em parte retirado de: [WWW] 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 pode-se fazer 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 é: [WWW] http://www.python.org/, para baixar os arquivos para poder instalar o interpretador e a biblioteca padrão basta ir no endereço [WWW] 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:

$ tar zxvf Python-VERSAO.tgz
$ ./configure
$ make
# make install # esse comando deverá ser executado como root
$ 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:

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

Entendendo Python

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.

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

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"

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

   1 x = 2
   2 FRASE = 'Isso é um exemplo simples e bobo'
   1 x = 'agora tudo mudou'
   2 FRASE = 3.2
   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

Tipos agrupados (listas, tuplas, dicionários)

Mais sobre 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

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 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.

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

Você notou que o print não ocorreu já que as variáveis meuNome e seuNome são diferentes.

Agora observe esse exemplo:

   1 # Exemplo IF 02
   2 In [1]: meuNome = "Adolfo"
   3 
   4 In [2]: seuNome = "Adolfo"
   5 
   6 In [3]: if meuNome == se
   7 setattr  seuNome
   8 
   9 In [3]: if meuNome == se
  10 setattr  seuNome
  11 
  12 In [3]: if meuNome == seuNome:
  13    ...:     print "Temos os nomes iguais!"
  14    ...:
  15 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:

   1 #Exemplo ELSE 01
   2 In [1]: meuNome = "Ruivaldo"
   3 
   4 In [2]: seuNome = "Adolfo"
   5 
   6 In [3]: if m
   7 map      max      meuNome  min
   8 
   9 In [3]: if meuNome == se
  10 setattr  seuNome
  11 
  12 In [3]: if meuNome == seuNome:
  13    ...:     print "Temos nomes iguais!"
  14    ...: else:
  15    ...:     print "Nossos nomes sao diferentes... :("
  16    ...:
  17 Nossos nomes sao diferentes... :(ERROR: EOF in multi-line statement

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 In [1]: x = 5
   3 
   4 In [2]: y = 10
   5 
   6 In [3]: if x > 5:
   7    ...:     print "X maior que Y"
   8    ...: else:
   9    ...:     print "Y maior ou igual a X"
  10    ...:
  11 Y maior ou igual a X

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.

Vamos a um exemplo similar ao anterior:

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

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

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

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:

   1 # Exemplo not
   2 In [1]: x = 5
   3 
   4 In [2]: y = 6
   5 
   6 In [3]: if not x == y:
   7    ...:     print "X eh diferente de Y"
   8    ...:
   9 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 o in:

* Modificador in *

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

Veja esses exemplos:

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

Estruturas de iteração ou loop

if not odeio_metallica:
    metallica = ['James','Kirk','Lars','Trujillo']
    for membro in metallica:
        print membro
   1 for i in range(50):
   2    print i
   1 opc = 1
   2 while opc != 0:
   3    # código e mais código...
   4    opc = int(raw_input("Digite 0 para sair \n > "))

Tratamento de erros e exceções

As sentenças try / except e try / finally são mutuamente excludentes, não podem misturadas (embora possam ser usadas uma 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 para tratar erros que não foram previstos. 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 'ocorreu algo inesperado!'

A sentença try / finally especifica um manipulador de limpeza, que será excutado 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

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 defs e classes 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).

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. Claro, módulos podem ser mais complexos em certos pontos de vista. Eu mesmo não vejo nada de muita complexidade. Pura praticidade!

Packages

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:

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

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. 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)

Exemplo:

   1 # definindo uma classe 'pai'
   2 class CD:
   3   def __init__(self, titulo):
   4     self.titulo = titulo
   5 
   6   def mudarTitulo(self, novoTitulo):
   7     self.titulo = novoTitulo
   8 
   9 # definindo uma classe 'filha'
  10 class CDAudio(CD):
  11 
  12   def __init__(self, titulo, autor):
  13     CD.__init__(self, titulo)
  14     self.autor = autor
  15     self.faixas = []
  16 
  17   def adicionarFaixa(self, numero, nome):
  18     self.faixas.append((numero, nome))
  19 
  20   def removerFaixa(self, numero, titulo):
  21     self.faixas.remove((numero, nome))
  22 
  23 novoCD = CDAudio('Physical Graphitte', 'Led Zeppelin');
  24 
  25 novoCD.adicionarFaixa(1,'Custard Pie')
  26 novoCD.adicionarFaixa(2,'The Rover')
  27 
  28 print dir(novoCD)
  29 print "CD: %s, %s" % (novoCD.titulo, novoCD.autor)
  30 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:

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)

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>]

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 >>>

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...)

última edição em 2005-05-16 11:39:59 por LuizEduardoBorges