Como Funciona?

[Manwë Súlimo]

ola, eu uso um programa aqui no serviço, que junto com ele vem um monte de coisa do Python...

Coisas como Python Trial e por ai vai...

por acaso p/ rodar um programa feito em Python tem que ter o Python instalado??

[Graymalkin]

Python é uma linguagem interpretada (diferente de linguagens compiladas como Delphi e C/C++, ou semi-compiladas como Visual Basic), daí a necessidade de ter o interpretador instalado para executar programas criados nela. Todavia, existem meios de embutir a biblioteca do interpretador em um arquivo (criando um arquivo executável) que funciona independentemente da instalação do interpretador (vide py2exe e cx_Freeze). Entretanto, nunca vi um "Python Trial" já que não existe uma versão comercial da linguagem, sendo ela inteiramente livre e gratuita.

Abraços,

Graymalkin

[Manwë Súlimo]

não é nem trial, acho q me expressei mau, mas nesse pacote de python que venho com o programa da p/ programa?? por tem tanto arquivo e programas que acho que da, tem documentos

no menu iniciar tem:

A pasta:

ActiveState ActivePython 2.2

com outros programas dentro

e outra pasta:

wxPython 2.4 for Python 2.2, com mais programas dentro

nisso dá pra programar???

e ela é boa mesmo ou não é??

até mais

[Graymalkin]

Ah sim, dá pra programar sim. Antigamente eu usava a distribuição da ActiveState (www.activestate.com), mas hoje em dia uso a distribuição oficial (www.python.org). Procure por Pythonwin ou IDLE na pasta do ActivePython (no Menu Iniciar->Programas). Uma coisa muito bacana de Python é ter um interpretador interativo: você digita os códigos e vê os resultados na hora.

Sim, Python é ótima! Se quiser, posso expor algumas características da linguagem (fazendo até uma comparação com VB, já que você está mais familiarizado com ele). Qualquer coisa, é só falar.

Abraços,

Graymalkin

[Manwë Súlimo]

Opa, gostaria sim, e se tiver algumas apostilas ou tutoriais gostaria mais ainda...

até mais

[Graymalkin]

No final de semana coloco aqui as características (se não eu vou passar a madrugada toda escrevendo... hehehe) e alguns links para tutoriais.

Abraços,

Graymalkin

[William Rodrigues]

No final de semana coloco aqui as características (se não eu vou passar a madrugada toda escrevendo... hehehe) e alguns links para tutoriais.

Karacas...

Chega a tanto?

hehehe

Abraços,

William Rodrigues

[Graymalkin]

Ô se chega! Estou até pensando em transformar em um artigo e colocar na Python Brasil.

Até,

Graymalkin

[Graymalkin]

Segue o texto (ficou meio grandinho... . E olha que no final eu ainda coloquei vários assuntos que não abordei, mas que poderia...):

Identação - Python força a utilização do recurso (é como podemos considerá-la em outras linguagens) de identar os códigos (o que é realmente uma boa prática de programação). Enquanto em outras linguagens a identação fica a critério do programador, em Python é ela que identifica quais linhas de código pertencem a uma determinada função, classe, if, for, while, etc. Com isso não temos um "endif", um "next", um "end function" ou "end sub", um "loop" ou "wend", etc. Um exemplo:

if a==2:
  print "a é 2"
  print "logo, a não é 3"
else:
  print "a, com certeza, não é 2"
  print "a pode ser 3"

Tipos de dados - Os tipos de dados apresentados em Python são de alto nível. Alguns tipos já podem ser reconhecidos, só pelo nome: string, int, long, float, bool, etc. Todavia, esses são básicos em quase todas as linguagens existentes. Os tipos de alto nível a que me refiro são mais especificamente as listas e os dicionários. Ambos os tipos já são parte da linguagem, ou seja, são tipos nativos. Listas são como vetores, porém podem guardar diferentes tipos de dados (inclusive outras listas). Exemplo de uma lista:

lista = [1, 2, 'teste', 2.3, True, ['a', 'b']]

E para obtermos os valores, podemos nos usar de índices, exemplo:

print lista[0]
print lista[2]
print lista[5][0]

Isso imprimirá, respectivamente: 1, teste e a. Apesar de muito parecidos com os vetores existentes no VB, existem diferenças sensíveis como a possibilidade de armazenar diversos tipos de dados em uma lista (no VB pode-se usar o tipo Variant para isso, mas explicarei mais abaixo porque isso não é a mesma coisa). Outra característica é que não se precisa definir um tamanho para a mesma (nem redimensioná-la; isso é automático). Pode-se também remover um item específico e a lista será redimensionada sozinha (coisa que não ocorre com um vetor). Já os dicionários são como listas (no sentido de que agrupam em um único local diversos dados), porém os índices são definidos pelo programador (bem semelhante às Collections em VB). Exemplo de um dicionário:

dicionario = {'teste': 'palavra teste', 1: 'valor um', 2: 'valor dois'}

E para obtermos os valores:

print dicionario['teste']
print dicionario[1]
print dicionario[2]

Além disso, como objetos, listas e dicionários (e praticamente todos os outros tipos citados) possuem métodos. Também podem ser criados a partir de suas classes (ao invés de usarmos [] e {}, usaríamos list() e dict()). Se eu quisesse colocar mais um item na minha lista, bastaria fazer:

lista.append('mais um item')

Já no caso do dicionário, eu nem preciso usar de um método para isso (apesar de poder), pois é possível fazer a atribuição direta (um recurso não encontrado nas Collections em VB):

dicionario['teste2'] = 'novo item'

Como chaves de um dicionário (índices) podem ser usados quaisquer dos tipos chamados imutáveis (só para ter uma idéia, strings, inteiros, floats, tuplas, etc. são tipos imutáveis, enquanto que listas não são; se quiser eu explico o porquê [não vou colocar aqui para não extender muito]). Outro fato é que, como os tipos são classes, e você pode criar classes, por dedução você pode criar seus próprios tipos. Tipagem fraca - Diferentemente do VB, que possui tipagem forte (strong typed), Python tem tipagem fraca. Isso significa que você não precisa declarar os tipos dos dados de um determinado objeto (entenda por objeto "quase" o que chamamos de "variável" no VB). Exemplo:

i = 3
palavra = "teste"
valor = 2.54
logico = True

Os tipos de cada objeto acima serão definidos automaticamente pelos valores atribuídos, dessa forma, eles serão, no caso acima, respectivamente: int, str, float e bool. Nada impede que eu reutilize o objeto "i", atribuindo o valor 5.64332 a ele. Automaticamente "i" passará a ser float. Podemos comprovar isso da seguinte maneira (o que está depois do # é comentário):

i=2
print type(i)       # retornará: <type 'int'>
i=5.64332
print type(i)       # retornará: <type 'float'>

No VB, se queremos que uma variável seja de um determinado tipo, devemos obrigatoriamente declará-la. É claro que podemos nos utilizar do tipo Variant e não termos que declarar uma por uma, todavia os tipos de cada uma das variáveis não é definido para seu tipo correto (permanecendo Variant). Por exemplo, em VB:

dim i
i=2

Qual o tipo de "i"? É Variant. Já:

dim i as integer
i=2

Qual o tipo de "i" agora? Agora é inteiro. Não é muito mais simples atribuir um valor e o tipo ser determinado sozinho (já que inevitavelmente atribuiremos algum valor em algum momento àquela variável) do que ter que descrever o tipo de cada uma delas? Strings e formatação: No VB temos a possibilidade de colocar aspas simples dentro de strings, já que as aspas do mesmo são duplas. Porém, e se quisermos colocar aspas duplas dentro de strings literais? Temos que fazer isso:

t = "isto ""é"" um teste"

Ou isso:

t = "isto " & Chr(34) & "é" & Chr(34) & " um teste"

Porém, em Python podemos escrever strings tanto com aspas simples quanto com aspas duplas. Por isso, é válido fazer:

t = 'isto "é" um teste'

Ou (se quisermos o contrário):

t = "isto 'é' um teste"

Ambas as formas (" ou ') são plenamente aceitas. Mas, no caso do VB, e se quisermos escrever uma string com múltiplas linhas? Teremos de concatená-la com vbCrLf (que representa o ENTER) para cada uma das linhas, exemplo:

linhas = "linha1" & vbcrlf & "linha2" & vbcrlf & "linha3"

Não seria mais fácil ter um método de escrever (literalmente) as três linhas e armazenar em uma variável? Python tem. Exemplo:

linhas = """linha1
linha2
linha3"""

Com três aspas duplas (ou três aspas simples) pode-se delimitar strings com múltiplas linhas. Outro capacidade das strings em Python é possuir caracteres de controle (como em C, e que não existem no VB). Dessa forma, aquele exemplo do vbCrLf ali de cima, poderia ser escrito (em Python) da seguinte maneira:

linhas = "linha1\nlinha2\nlinha3"

O "\n" significa justamente o mesmo que o vbCrLf. Porém, além dele existem diversos outros. Quanto a formatação de strings, imagine a seguinte SQL (string) em VB:

sql = "SELECT * FROM tabela WHERE nome='" & nnome & "' AND idade=" & nidade & ";"

Em Python acho que isso fica mais claro com a formatação permitida pelo %. Exemplo:

sql = "SELECT * FROM tabela WHERE nome='%s' AND idaded=%i;" % (nnome, nidade)

Note que não há necessidade de concatenação (que em VB é feita pelo operador &, mas em Python é pelo +). Simplesmente ocorre a substituição das strings "%s" e "%i" pelos seus respectivos valores (nnome e nidade). O "%s" significa que trata-se de uma string e o "%i" significa que trata-se de um inteiro. Existem ainda outras formatações possíveis. Os valores reais (nnome e nidade) estão em uma tupla (não falei desse tipo de dados), porém poderiam também estar em um dicionário. Portanto, poderíamos fazer:

dicionario = {'nome': 'um nome', 'idade': 20}
sql = "SELECT * FROM tabela WHERE nome=%(nome)s AND idade=%(idade)i;" % dicionario

O que deixa ainda mais clara a formatação (para onde vai o quê). Classes: A criação de classes em Python é super simples e exige um esforço mínimo. Para se ter uma idéia com duas linhas (que até podem ser agrupadas em uma) pode-se criar uma classe. Exemplo:

class Teste:
  pass

A instrução "pass" não faz nada (ela fica ali apenas porque uma classe, ou uma função, precisa de um código qualquer abaixo; do mesmo jeito podemos criar uma função que não faz nada). No VB as classes ficam em arquivos .CLS (sendo uma classe por arquivo) que não funcionam por si só e são utilizados no projeto. Em Python, classes podem ser declaradas em qualquer lugar (dentro de funções, dentro de outras classes, por exemplo). Portanto, um único arquivo .py pode ter quantas classes você quiser, e o mais interessante é que este arquivo pode funcionar de forma independente (ele, por si só, tem funcionalidade). Voltando as classes, como criaríamos um objeto a partir da mesma? Em VB isso poderia ser feito de duas maneiras:

dim teste as new clsTeste

Ou:

dim teste as clsTeste
set teste = new clsTeste

Em Python, isso seria assim:

teste = Teste()

Como Python é sensível ao caso, "teste" é diferente de "Teste" (e por convenção, utilizamos a letra maiúscula nos nomes das classes e minúsculas nos dos objetos). Mas, uma classe simples assim tem alguma utilidade? Em Python, sim. Veja:

teste.nome = 'Junior'
teste.telefone = '555-5555'

Onde eu declarei os atributos (ou campos)? Em lugar algum. Mas, Python permite a atribuição dinâmica de atributos. De qualquer forma, eu poderia tê-los colocado na classe. E, quanto aos métodos? O mesmo poderia ser feito, mas não vale a pena (já que uma das idéias de um objeto é encapsular métodos e dados num mesmo local; por isso não faz sentido declarar os métodos fora e inseri-los no objeto, apesar de ser possível). Um exemplo agora de uma classe um pouco mais útil:

class Cliente:
  def __init__(self, nome, telefone):
    self.nome = nome
    self.telefone = telefone

  def mostrar(self):
    print self.nome, self.telefone

Por "def" você pode imaginar a declaração de uma função, rotina ou método (no VB usamos function e sub). Por "__init__" (falarei dele no próximo tópico) você pode imaginar o evento Class_Initialize que é executado no VB quando uma instância (objeto) de uma classe é criada. Diferentemente do Class_Initialize podemos definir parâmetros para a criação da classe. E "self"? A palavra vem do inglês "próprio" ou "o mesmo", e é o próprio objeto. Todos os métodos de uma classe recebem como primeiro parâmetro o próprio objeto ("self" é apenas outra convenção, pode-se usar qualquer palavra em seu lugar). Com a classe acima, podemos fazer:

cliente1 = Cliente('Junior', '555-5555')
cliente2 = Cliente('Peter', '666-6666')

cliente1.mostrar()
cliente2.mostrar()

Note que ao chamar os métodos ou mesmo durante a criação dos objetos, o primeiro parâmetro (self) nos é ignorado. Em Python temos ainda a capacidade de herdar (recurso chamado de herança) atributos e métodos de uma classe em outra (isso é considerado como um recurso essencial de qualquer linguagem OO, e o VB peca por isso). Ao herdar os métodos de uma classe em outra podemos só substituir os métodos que quisermos, o que aliás é bem comum (vários módulos em Python já vem preparados para serem reutilizados, bastando você substituir um método ou outro para obter os resultados desejados). Customização de classes - Uma das coisas que mais me chamou a atenção em Python é a capacidade de customizar o comportamento de objetos. Imagine um vetor (que não é um objeto em VB, mas serve como exemplo) no seguinte código (em VB):

vetor = Array(1, 2, 3, 4)
MsgBox vetor

Você recebe um erro, de tipo incorreto. O mesmo ocorre com qualquer outro objeto que você tenha criado. Apenas determinados tipos são convertidos para string e mostrados nesse caso (como inteiros, booleanos e números de ponto flutuante, por exemplo). Vejamos agora uma lista em Python:

lista = [1, 2, 3, 4]
print lista

Como já vimos antes, uma lista é muito semelhante a um vetor. No caso acima, a lista aparecerá exatamente do mesmo jeito que vemos na declaração ("[1, 2, 3, 4]"). O mesmo ocorre com dicionários (e não ocorre com Collections em VB). Ou seja, todos os tipos em Python tem representações em string. Em Python, podemos criar representações para nossas próprias classes. Por exemplo, com a aquela classe Cliente, eu poderia fazer com que ao imprimi-la, aparecesse a frase: "este é o cliente tal com o telefone tal". Para isso, bastaria sobrescrever os métodos __repr__ e/ou __str__. Outros itens que são customizáveis são: atributos (assim como as Properties em VB), criação de objetos do tipo contêiners (imagine criar a sua própria lista ou dicionário, ou mesmo usar os recursos de indexação para outros fins), entre outros. Ainda sobre a customização, o que ocorre quando você soma dois vetores? Erro! Do mesmo jeito que tentar representar um vetor. Em Python, o que ocorre quando se soma duas listas? Os conteúdos delas são juntados em uma única lista:

a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = a+b

E o mesmo pode ser customizado do que jeito que quisermos. Imagine que a partir daquela classe Cliente eu crie vários clientes. Por um descuido, dois destes clientes se referem a mesma pessoa/empresa. Como eu poderia representar essa junção (de forma bastante abstrata)? Simplesmente, poderia ser:

clientenovo = cliente1+cliente2

Os demais operadores (como -, *, /, etc.) também podem ser customizados de que forma que se você fizesse uma operação qualquer entre dois objetos daquela classe (ou mesmo entre outros objetos) o resultado seria exatamente o que você quisesse. Isso é que se chama sobrecarga de operadores. O __init__ citado no exemplo do tópico anterior é justamente a customização que pode ser feita para a criação de um objeto. Para a destruição do objeto também se tem um método (chamado __del__). Introspecção e execução dinâmica - Outros dois itens que chamaram muito a minha atenção para Python. Chamo de introspecção a capacidade de saber os métodos e atributos existentes em um determinado objeto. Isso pode ser obtido com a função dir(), como no exemplo a seguir:

print dir(cliente1)

Supondo a classe criada previamente, teríamos a lista: ['__doc__', '__init__', '__module__', 'mostrar', 'nome', 'telefone']. Em VB só vemos os métodos/propriedades quando digitamos o nome do objeto seguido de um ".", e o pior é que não temos como trabalhar com esse tipo de informação. O outro ponto é a execução dinâmica. Uma das coisas que quase nunca está presente em linguagens compiladas (apesar de VB ser semi-compilada, também não tem esse recurso; digo "quase nunca" porque Clipper tem esse recurso (ainda que limitado), apesar de também ser semi-compilada). Imagine poder fazer o seguinte:

exec "a=2"
exec "b=3"
exec "print a+b"

Veja que os códigos são passados como strings e são executados como se fizessem parte do programa. Ao invés de usarmos "exec" poderíamos usar a função eval() e obter assim o resultado de uma expressão (por exemplo, não temos que ficar limitado a elas):

resultado = eval("2+3/4*85787+232")

As possibilidades que vejo para isso são diversas. Simples scripts que fazem alterações em estruturas de bancos de dados poderiam ser criados e executados a partir do programa principal através desse método. Cálculo de expressões complexas ou simples. Preenchimento de objetos ("variáveis") a partir de dados de qualquer natureza (como XML, por exemplo, o que já fiz de fato). Entre outras possibilidades.

Módulos - Python tem uma vasta biblioteca de módulos prontos para uso. Com o módulo smtplib você consegue enviar emails (com autenticação!) precisando escrever cinco linhas apenas. Existem ainda módulos para POP3, FTP, HTTP, etc. Sabe o que o ASP e o Apache fazem? Servidor web? Python tem módulos para isso também. Além disso, também tem CGI, o que permite substituir o VBScript e o PHP, por exemplo. Outros módulos: threads (execute diferentes tarefas simultaneamente, tkinter (interface gráfica nativa), zipfile (compacte e descompacte arquivos zip), re (expressões regulares), xml (trabalhe com arquivos XML), entre dezenas de outros.

E estes foram só alguns tópicos que levei em consideração para descrever. Imaginei ainda outros que são de grande valia para qualquer programador como: list comprehensions (programação funcional), funções como classes, qualquer tipo de dado pode ser retornado em funções, persistência de objetos (poder gravar objetos em arquivos e depois recuperá-los), desvio de dispositivo de saída, substituição de objetos por outros de mesmas características porém personalizados, tratamento de erros (com try...except...[else]), geradores, o fato do "for" iterar sobre listas e geradores entre outros.

Abraços,

Graymalkin