Alguns pormenores

Cá estou de volta, depois de uma ausência de alguns meses. Não, não desisti de escrever, apenas deixei de ter tempo. Mas agora vou redimir-me.
E vou aproveitar este regresso para atar algumas pontas soltas, de coisas que aprendi entretanto, aqui e ali. Vamos a isto.
Vamos começar por voltar ao IDLE. Há uma coisa que descobri e que dá muito jeito quando se estão a fazer contas nas máquinas de calcular: usar o último valor calculado. Nas calculadoras, pode ser o "ANS", ou "Recall". Mas vamos ver com exemplos, que é sempre mais fácil de entender:

>>> 2 + 3 5 >>> _ * 5 25 >>> _ 25

Como se consegue perceber, usar o símbolo '_' permite-nos obter o último objeto inserido ou obtido no modo interativo. Sim, o último objeto. Se fizermos o mesmo com cadeias de caracteres, também resulta:

>>> 'Texto escrito' 'Texto escrito' >>> _ 'Texto escrito'

Giro, não é?
E outra coisa que descobri: os números inteiros em Python tem precisão infinita!!! Não fazia ideia! O que quer isto dizer? Experimentem:

>>> 2324328643274826487*23428734632846 54456078982808883241978300992002 >>> _ * 55465465465465465464564 3020431768205645866255231705359115636508579632978417128 >>> _ ** 4 83229276179341914052177247922360198310600096860756479458237334163417416895989199680022872164696168962399992046990547315630606883203434211280232750588277764833775698281886726905118556842774846290016959699906061197971456

Ora aqui está: ao contrário de outras linguagens, o cálculo com inteiros apresenta sempre todos os algarismos!
E para finalizar, mais um detalhe. Já tínhamos visto que as cadeias de caracteres se podem definir com ' ' ou com " ". Mas faltava mencionar que também podem ser definidas com 3 aspas (""" """). A vantagem destas é que podemos definir texto ao longo de várias linhas:

>>> """esta linha vai durar várias linhas""" 'esta linha\nvai durar várias\nlinhas'

Note que apareceram ali uns '\n' pelo meio. Isto é um código de nova linha que é interpretado quando se usa o comando print(). Ainda voltaremos a ver para que servem estas cadeias...

Vamos falar de booleanos...

Lembra-se de já termos falado em booleanos? Pois hoje vamos ver ver umas funções especialmente desenhadas para este tipo de variáveis. Vamos começar por all():

>>> all([0,1,0,3,5]) False >>> all((0,1,0,3,5)) False >>> all((5,1,10,3,5)) True >>> all([]) True >>> all([True,False,True]) False

Bem, o que temos aqui? Pense no all() como uma espécie de operador and com vários argumentos encaixados dentro de um iterável (uma lista ou um tuplo). Esta função resulta em True apenas se todos os elementos forem True (ou se o iterável estiver vazio). Claro que a definição do que é falso tem de ter tida em conta, como vimos aqui. No entanto, temos de notar uma coisa: embora uma lista vazia [] valha como False, isto não é o mesmo que all([]), que testa o conteúdo da lista e não a própria lista.
Se existe uma espécie de and para iteráveis, será que existe uma espécie de or? Claro que sim, e chama-se any():

>>> any([0,1,0,3,5]) True >>> any((0,0,0,0,0)) False >>> any([]) False

Como seria de esperar, o any(), resulta em False apenas se todos os elementos forem False. Bem, mas com isto tudo, existe alguma maneira de sabermos qual o valor booleano de algo sem termos de nos lembrar das regras explicitadas no outro dia? Sim, felizmente existe a função bool(), que converte o seu argumento num True ou False, dependendo do que está lá dentro:

>>> bool([]) False >>> bool(None) False >>> bool(0) False >>> bool('') False >>> bool() False

Aqui assim podemos ver o que é False em Python com mais facilidade. E por hoje é tudo! Curtinho, mas informativo!

E finalmente os dicionários

Vamos então falar finalmente sobre dicionários. Estas estruturas são também parecidas com as listas, mas têm a particularidade de serem construídas por pares de chave:valor. A ideia é termos uma correspondência direta entre valores. Nada como um exemplo para ilustrar:

>>> dicio = {0:'zero', 1:'um', 'UM':1, 'ZERO':0} >>> dicio[0] 'zero' >>> dicio['UM'] 1

Comentários: o dicionário cria-se com chavetas {}, e cada par chave:valor é separado por dois pontos :, enquanto os pares são separados por vírgula. Podemos então aceder ao valor correspondente a cada chave usando a notação dicionário[chave]. As chaves e os valores podem assumir o tipo que quisermos, seja um número inteiro ou com vírgula, uma cadeia de caracteres ou mesmo um tuplo. Mas enquanto as chaves têm que ser imutáveis, não podendo aceitar listas como tipo, os valores podem aceitar listas. Além disso, não podem existir duas chaves iguais, e se ocorrer, a chave que permanece válida é a última a ser inserida. Um exemplo funciona melhor:

>>> dicio = {0:'zero', 1:'um', 0:'ZERO'} # reparar nos dois 0!! >>> dicio[0] 'ZERO'

Eu estou sempre a apresentar outras coisas: para fazermos um comentário em Python, basta escrever o símbolo de cardinal # e daí para a frente é tudo ignorado nessa linha. Isto também se aplica a programas em Python. E acho que o exemplo acima explica-se a si mesmo.
Também podemos alterar, adicionar e eliminar elementos num dicionário:

>>> dicio2 = {'Nome':'Chico', 'Idade':25} >>> dicio2['Nome'] 'Chico' >>> dicio2['Nome'] = 'Francisco' # alterar o valor da chave 'Nome' >>> dicio2['Nome'] >>> dicio2['Apelido'] = 'Santos' # adicionar uma nova chave >>> dicio2   # ver o conteúdo do dicionário {'Idade': 25, 'Nome': 'Francisco', 'Apelido': 'Santos'} >>> del dicio2['Idade'] # apagar o par de chave 'Idade' >>> dicio2 {'Nome': 'Francisco', 'Apelido': 'Santos'} >>> del dicio2 # apagar o dicionário todo

Assim já ficamos com uma boa ideia do que se pode fazer com dicionários! De notar que não se pode fazer slicing com dicionários. Mas podemos iterá-los com um ciclo for:

dicio = {'Idade': 25, 'Nome': 'Francisco', 'Apelido': 'Santos'} for i in dicio:     print(i, dicio[i])

Isto vai dar:

Idade 25 Nome Francisco Apelido Santos

Também podemos usar as funções min(), max(), len() e sorted(), e também o operador in. Vejamos como funcionam:

>>> dicio = {'Idade': 25, 'Nome': 'Francisco', 'Apelido': 'Santos'} >>> min(dicio) # resulta na primeira chave, em ordem alfabética 'Apelido' >>> max(dicio) # resulta na última chave, em ordem alfabética 'Nome' >>> len(dicio) 3 >>> sorted(dicio) # ordenar as chaves alfabeticamente ['Apelido', 'Idade', 'Nome'] >>> 'Nome' in dicio # ver se 'Nome' é uma chave True >>> 'Santos' in dicio # ver se 'Santos' é uma chave False

Como deve ter notado, todas estas funções se aplicam às chaves. Para aceder diretamente a valores, teremos de voltar a este tema mais tarde, depois de falarmos de programação por objetos.
Finalmente, vamos falar na função geradora de um dicionário, dict():

>>> dicio = dict(Idade=25, Nome='Francisco', Apelido='Santos') >>> dicio {'Apelido': 'Santos', 'Idade': 25, 'Nome': 'Francisco'}

Como se percebe, usa-se como argumento pares chave=valor separados por vírgulas, com a nota de que aqui a chave tem que ser uma cadeia de caracteres.

E pronto, para a semana há mais!

Mais estruturas de dados: os tuplos

Realmente, já vamos para a 13ª contribuição para este blogue e ainda não falámos em duas estruturas de dados muito importantes em Python: os tuplos e os dicionários. Estas estruturas fazem lembrar as listas, mas têm características próprias. Vamos começar pelos tuplos. Um tuplo é como uma lista, mas os seus elementos são imutáveis. Cria-se como se cria uma lista, só que em vez de parêntesis retos [], usam-se parêntesis curvos (), embora estes sejam opcionais na sua criação:

>>> (1,2,3) (1, 2, 3) >>> 1,2,3 (1, 2, 3)

Tal como numa lista, podemos usar slicing para aceder a vários elementos:

>>> a=(1,2,3,4,5,6) >>> a[1] 2 >>> a[2:4] (3, 4) >>> a[::2] (1, 3, 5) >>> a[1::2] (2, 4, 6)

Tal como com as listas, nos tuplos podemos obter o elemento 1 (a contar a partir do elemento 0) e os elementos 2 a 4, excluindo o 4. Aqui aproveito e mostro outra maneira de fazer o slicing: com três parâmetros. Os dois primeiros continuam a ser o primeiro e o último, excluindo o último. Se não indicarmos nenhum, cobre todos os elementos, mas o terceiro parâmetro indica qual o salto entre elementos. Nos exemplos acima, salta de 2 em 2 elementos. Giro, não é? Isto também funciona com cadeias de caracteres:

>>> 'Teste de saltarelos'[::2] 'Tsed atrls' >>> 'Teste de saltarelos'[::-1] 'soleratlas ed etseT' >>> 'Teste de saltarelos'[::-3] 'setsdtT'

Bem, mas voltemos aos tuplos. Como já mencionei, ao contrário das listas, os tuplos são imutáveis. Assim, não podemos alterar um elemento de um tuplo, nem apagar um elemento. Só podemos adicionar elementos (que corresponde a criar um tuplo novo):

>>> a = (1,) >>> a = a + (2,3) >>> a (1, 2, 3)

Algumas notas: sim, quando fazemos o tuplo de um só elemento (1,), tem de ter uma vírgula, para não se confundir com um cálculo com parêntesis. Podemos mesmo retirar os parêntesis, mas a vírgula tem de ficar.
E tal como com as listas, também podemos iterar os tuplos:

nums = (1, 4, 5, 6, 3) for i in nums:     print(i)

Vai resultar em:

1 4 5 6 3

Em comum com as listas, os tuplos também aceitam as funções max(), min(), sum(), len(), reversed() e o operador in, que funcionam exatamente da mesma maneira. Também podemos aplicar a função sorted() num tuplo, mas o resultado é uma lista. E também temos uma função que cria tuplos, que incrivelmente se chama tuple():

>>> tuple(reversed([6,4,2,7,9])) (9, 7, 2, 4, 6)

Esta função, tal como a sua análoga list(), também tem outras aplicações, ilustradas a seguir:

>>> tuple('Python') ('P', 'y', 't', 'h', 'o', 'n') >>> tuple(range(6)) (0, 1, 2, 3, 4, 5)

Voltando atrás à atribuição de variáveis, vemos agora que a atribuição de várias variáveis separadas por vírgulas (um,dois,tres = 1,2,3) não é mais do que usar um tuplo para este fim...
Finalmente, porquê este nome de 'tuplo'? Bem, se pensarmos nos nomes 'duplo', 'triplo', 'quádruplo'... 'múltiplo', vemos que foi daí que veio. As coisas que vamos aprendendo...

Voltemos aos ciclos

Olá de novo. É altura de voltarmos aos ciclos, seja através de for, seja através de outro tipo de ciclos que vamos já ver. Já mencionei que se usa muito o comando for com a função range(). Vamos ver um programa de exemplo em que apresentamos o comando continue:

for i in range(10):     if i%2 == 0:         print(i,'é par!')         continue     print(i,'é impar!')

Se tiver experimentado executar este pequeno programa, verá que o resultado é:

0 é par! 1 é impar! 2 é par! 3 é impar! 4 é par! 5 é impar! 6 é par! 7 é impar! 8 é par! 9 é impar!

O que é relevante aqui é que, sempre que se chega a um comando continue dentro de um ciclo for, o ciclo é interrompido e passa automaticamente para a iteração seguinte, ignorando os comandos abaixo de continue. Vamos ver agora o que faz o comando break:

for i in range(10):     if i > 4:         print('Estou farto de números!')         break     print(i)

Isto vai resultar em:

0 1 2 3 4 Estou farto de números!

Podemos ver que o comando break dentro de um ciclo for vai fazer com que se salte para fora do ciclo. Ainda há mais um comando que podemos incluir:

lim = int(input('Dá-me um número: ')) for i in range(10):     if i > lim:         print('Estou farto de números!')         break     print(i) else:     print('Chegámos mesmo ao fim!')

Este programa vai pedir um número, e se esse número for menor que 9, vai "fartar-se de números", caso contrário vai "chegar mesmo ao fim". Isto é, o else no final do ciclo for só é executado se as iterações do ciclo chegarem ao fim. Curioso, não é?
Mas vale a pena mencionar que existe um outro tipo de ciclo, o que usa o comando while. Neste tipo de ciclos, enquanto a condição em frente a while for verdadeira, o ciclo repete-se infinitamente (o que pode ser verdadeiramente perigoso!):

r = '' while r != 'por favor':     r = input('Pede para sair com modos... ')     if r=='':         continue     elif r=='deixa-me!':         print('Vá, não te irrites!...')         break else:     print('Muito bem educado!')

Ora aqui está um programa que serve para mostrar que todos os comandos acima também se aplicam aos ciclos while. Se experimentar este programa, vai ver que só consegue sair se escrever uma de duas frases: 'por favor' ou 'deixa-me!'. Se não escrever nada, ele usa o continue e pede logo para escrever de novo. Se escrever 'deixa-me!' consegue sair pelo break, e se escrever 'por favor', sai do ciclo através do else. Simples, não é? Mas repito, cuidado com ciclos infinitos!

Funções e listas

Já andámos a ver várias funções, de conversão ou matemáticas. Mas agora vamos abordar algumas funções que afetam listas. Comecemos por algumas bastante simples e diretas:

>>> max([1,5,3,7,8,2]) 8 >>> min([1,5,3,7,8,2]) 1 >>> sum([1,5,3,7,8,2]) 26

Claro que estas funções apenas resultam se as listas contiverem apenas números. Como seria de esperar, a função max() apresenta o maior número na lista, a função min() apresenta o menor, e a função sum() apresenta a soma de todos os números na lista. As funções max() e min() também podem usar como argumento números ou variáveis separados por vírgulas:

>>> max(1,5,3,7,8,2) 8 >>> min(1,5,3,7,8,2) 1

Também temos um outro operador que funciona tanto em listas como em cadeias de caracteres, o operador in, que testa se algo se encontra numa lista (ou numa cadeia de caracteres) e responde com um booleano:

>>> 4 in [1,2,3,4] True >>> 0 in [4,8,7,4,9] False >>> 'a' in 'antonio' True >>> 'b' in 'antonio' False

De notar que é a segunda vez que aparece o operador in, pois também é usado de modo diferente nos ciclos for.
E agora vamos ver outra função que é muito comum em várias linguagens: len(). Sendo a abreviatura de length (comprimento), resulta no comprimento de várias estruturas:

>>> len('batata') 6 >>> len([4,8,7,4,9]) 5

Aplicado a cadeias de caracteres, diz-nos quantos tem, e em listas, indica o número de elementos da lista mais externa (sim, as listas podem ter listas como elementos).
Ora então chegamos finalmente a range(). No Python 2.x, era uma função que produzia uma lista, mas na versão 3.x produz uma sequência imutável. Antes de mais, o que faz isto? Em Python 2.x, fazia:

>>> range(3) [0, 1, 2] >>> range(3,6) [3, 4, 5] >>> range(1,11,2) [1, 3, 5, 7, 9]

Em suma, quando só tem um argumento, range produzia uma lista de zero até esse argumento excluindo-o. Com dois argumentos, indica qual o número de onde começa e até onde vai, excluindo o final. Com 3 argumentos, é como com 2 mas o último argumento indica quanto se soma em cada iteração. Em Python 3.x, é quase a mesma coisa, mas se em 2.x se produzia uma lista que se podia depois modificar, em 3.x produz-se uma "lista-usa-e-deita-fora". Os exemplos acima em Python 3.x vão dar:

>>> range(3) range(0, 3) >>> range(3,6) range(3, 6) >>> range(1,11,2) range(1, 11, 2)

Parece confuso, mas na realidade a diferença é subtil. range() é muito usado em conjunto com o comando for, como no programa abaixo:

for i in range(0,15,3):     print(i)

que vai resultar em:

0 3 6 9 12

Este resultado seria o mesmo em Python 2.x. Mais tarde voltaremos a estas sequências imutáveis...
Falando ainda destas sequências, temos mais uma função que resulta numa destas, a função reversed(). Como o próprio nome indica, esta função inverte a sequência de uma lista que lhe seja fornecida como argumento, e resulta num iterável que corresponde à sequência invertida. Aqui já não há diferença de versões. Para aceder ao resultado, temos de iterar cada um dos elementos, como por exemplo:

for i in reversed([6,4,2,7,9]):     print(i)

dá o seguinte:

9 7 2 4 6

Se experimentar:

>>> reversed([6,4,2,7,9]) <list_reverseiterator object at 0x02AEFA30>

O que não dá muito jeito... Mas felizmente, temos outra função que trata disto: list(). Esta converte o seu argumento numa lista, o que já dá muito jeito!

>>> list(reversed([6,4,2,7,9])) [9, 7, 2, 4, 6]

Já agora, a função list() tem outras aplicações, ilustradas a seguir:

>>> list('Python') ['P', 'y', 't', 'h', 'o', 'n'] >>> list(range(6)) [0, 1, 2, 3, 4, 5]

Isto já permite umas coisas engraçadas, se puxar pela imaginação...
E vamos terminar com uma última função, sorted(), que serve para ordenar uma lista. Os exemplos são bastante elucidativos:

>>> sorted([6,4,2,7,9]) [2, 4, 6, 7, 9] >>> sorted([6,4,2,7,9], reverse=True) [9, 7, 6, 4, 2]

Como dá para perceber, podemos escolher a ordem, ascendente ou descendente, dependendo do valor que atribuímos ao argumento opcional reverse. E por hoje é tudo!

Mais funções e operadores que dão jeito

Temos visto algumas funções de Python que já nos permitem obter algumas conversões interessantes. Mas existem outras funções de cariz mais matemático, que vale a pena abordar agora. Comecemos pelas seguintes:

>>> abs(-4) 4 >>> abs(-4.7) 4.7 >>> round(4.567) 5 >>> round(4.567, 2) 4.57

Como já deve ter percebido, a função abs() devolve o absoluto de um número, isto é, o número sem sinal. Na prática, converte números (inteiros ou decimais) negativos em números positivos.
A função round() arredonda números. Se o argumento for só um número, arredonda-o ao inteiro mais próximo. Com dois argumentos, o segundo é o número de casas decimais pretendidas. Nada de especial até aqui.
E continuamos com pow(). Na sua forma mais simples, pow(x, y) é outra maneira de escrever x**y, ou seja, x elevado a y. No entanto, pow(x, y, z) é o mesmo que x**y%z, isto é, x elevado a y, módulo z. Tenho a certeza que vai descobrir alguma utilidade para isto!...
E também temos divmod(). Esta função, como o próprio nome indica, dá o divisor e o módulo de dois números. Um exemplo explica melhor:

>>> 7 // 3 2 >>> 7 % 3 1 >>> divmod(7, 3) (2, 1) >>> divmod(4.8, 2) (2.0, 0.7999999999999998)

Este último exemplo ilustra bem o problema de aproximações imperfeitas de números decimais. Claro que o resto deveria ser 0,8.
E agora temos uma função muito gira: eval(). Esta pega numa cadeia de caracteres e tenta avaliar se o seu conteúdo é uma expressão matemática válida. Mais um exemplo:

>>> eval('2*3 + 5') 11 >>> eval('2**8-1') 255 >>> x=6 >>> eval('x*4 - 7') 17

Se não for uma expressão matemática válida, dá erro... Mas já viu bem o último exemplo? Apesar de o x ser uma variável, dado que lhe foi atribuído um valor, x é corretamente avaliado dentro da expressão e a função consegue usá-lo para calcular o resultado final! Eu acho isto giro...
Muito bem, vamos passar para outro tipo de matemática, a lógica booleana. E vamos confirmar que em Python também existem os três típicos operadores de conjunção (and), disjunção (or) e negação (not):

>>> 1 and 1 1 >>> True or False True >>> not False True >>> not 0 True

Pois é, aqui temos de fazer uma ressalva muito importante: embora a lógica booleana apenas trabalhe com valores de Falso ou Verdadeiro, em Python há vários valores que são interpretados como Falso:

• None (um valor especial que se pode atribuir a uma variável, que significa que não tem valor)
• False (óbvio, não?)
• zero em qualquer tipo numérico (0, 0.0, 0j)
• Qualquer sequência vazia: '', [], (), {} (uma cadeia de caracteres vazia, uma lista vazia, e outros tipos de sequência que veremos mais tarde)

Todos os outros valores são considerados Verdadeiros. Mas o melhor mesmo é não inventar muito e tentar usar essencialmente True ou False como operandos destes operadores, para evitar resultados inesperados...
Claro que o local óbvio para usar os operadores acima é num comando if, onde poderá construir condições mais elaboradas com o auxílio destes operadores. Experimente!

Conversões para todos os gostos

Na semana passada vimos uma função curiosa que quase passou despercebida: int(). O que vimos é que esta função converte o seu argumento num número inteiro. Nada de especial até aqui. No entanto, o pormenor interessante é que o seu argumento pode ser de vários tipos: inteiro, decimal ou cadeia de caracteres. Se tentarmos:

>>> int(4) 4 >>> int(4.7) 4 >>> int('4') 4

O resultado vai ser sempre 4, sem nenhum tipo de problema. Com um argumento do tipo decimal, o resultado é o inteiro truncado. Quando o argumento é uma cadeia de caracteres, deve poder traduzir-se diretamente num número inteiro, caso contrário resulta em erro. Por exemplo, '4 a', '4.0' ou '4,0' não vão funcionar. No entanto, há uma exceção: quando o argumento é uma cadeia de caracteres válida para representar um número noutra base, podemos usar esta função para o converter em inteiro de base 10. Por exemplo, 25 em binário (base 2) é 11001, portanto podemos usar int() para converter binário em decimal:

>>> int('11001', 2) 25

Isto funciona para qualquer base entre 2 e 36. Por exemplo:

>>> int('11001', 24) 345601 >>> int('1abc', 16) 6844 >>> int('ABC', 16) 2748 >>> int('Zx', 36) 1293

Porquê até 36? Porque apenas podemos representar números com os 10 dígitos e 26 caracteres (maiúsculas ou minúsculas), o que dá um total de 36.
Mas já que estamos com a mão na massa, vamos ver que outras funções de conversão existem. Para começar, temos str(), que converte o argumento em cadeia de caracteres:

>>> str(8) '8' >>> str(5.2) '5.2' >>> str('90') '90'

Mais uma vez, o argumento pode ser um número inteiro, um decimal ou uma cadeia de caracteres.
Se quisermos converter o argumento em número decimal, usamos float():

>>> float(4) 4.0 >>> float('5.2') 5.2 >>> float(8.9) 8.9

E para compor o ramalhete de funções de conversão, falta mencionar complex(). Esta converte uma cadeia de caracteres ou dois números inteiros ou decimais num número complexo:

>>> complex(2,3) (2+3j) >>> complex(2.5,7) (2.5+7j) >>> complex('2.4-1.5j') (2.4-1.5j)

De notar que a cadeia de caracteres não pode conter espaços entre o sinal e as partes real e complexa do número, senão resulta num erro.
Em qualquer uma das funções acima, o argumento pode ser uma variável, como seria de esperar, e o resultado pode ser atribuído a uma variável. Isto é geralmente possível com todas as funções, e as exceções serão sempre referidas.
Muito bem, agora vamos ver duas funções em que uma é o inverso da outra: chr() e ord():

>>> chr(65) 'A' >>> ord('A') 65 >>> chr(10084) '❤'

O resultado de chr() é o caracter Unicode correspondente ao número inserido (que vai de 0 a 65535), e ord() resulta no código Unicode do caracter (o argumento só pode ser uma cadeia de 1 caracter).
E para finalizar, três funções que nos permitem obter números noutra base diferente da decimal:

>>> hex(255) '0xff' >>> oct(255) '0o377' >>> bin(255) '0b11111111'

De notar que o resultado é uma cadeia de caracteres. No entanto, os números inteiros também podem ser diretamente representados pelos seus equivalentes em hexadecimal (base 16), octal (base 8) e binário (base 2):

>>> 0xff 255 >>> 0o377 255 >>> 0b11111111 255

Finalmente, para esclarecer quaisquer dúvidas: o primeiro símbolo é um zero e não um O, e o 'x', o 'o' e o 'b' podem ser em maiúsculas ou minúsculas.

Comandos condicionais

Olá a quem estiver aí.
Como já deve ter reparado, pouco a pouco vamos aprendendo como construir um programa que faça algo de jeito. Mas o que torna um programa de computador realmente interessante é a capacidade de decidir fazer coisas diferentes de acordo com os dados que lhe fornecemos. E é para isso que existem os comandos condicionais. Vamos supor que queremos que o programa nos pergunte por um número e que veja se é positivo ou negativo:

num = input('Escreve um número: ') if int(num) < 0:     print('O número é negativo') else:     print('O número é positivo')

Muito bem, neste pequeno programa já há muito sumo a espremer! Vamos analisá-lo linha a linha.
Começamos por obter a partir do utilizador uma entrada a partir do teclado, e aqui está a primeira novidade: se escrevermos uma cadeia de caracteres no interior dos parêntesis de input(), esta cadeia vai servir como pergunta.
Se bem se lembra, tudo o que escrevemos para input() é interpretado como uma cadeia de caracteres, e se queremos que seja convertido num número, usamos a função int(), que converte o seu argumento num número inteiro. Assim, na segunda linha temos um comando condicional, que começa com if e de seguida uma condição int(num) < 0. Aqui temos um primeiro exemplo de um operador de comparação, o menor-do-que. O resultado será um booleano, isto é, ou é verdadeiro ou é falso, dependendo do número que foi inserido em num pelo utilizador. De seguida, surgem dois pontos, a indicar que irá ter início um bloco de código, que terá de ser indentado a indicar o que será executado se a condição for verdadeira.
A terceira linha é o bloco de código que é executado, e é um comando print() a escrever que o número é negativo, o que acontece quando a condição em frente de if se verifica. Este bloco de código poderia ter várias linhas, desde que tivessem todas a mesma indentação.
A quarta linha tem o comando opcional else, seguido de dois pontos. É opcional porque poderíamos decidir fazer executar algo apenas quando a condição de if se verificasse. Mas podemos decidir que vai acontecer algo apenas quando não se verificar a condição, definindo um novo bloco.
Finalmente, a última linha é o comando que é executado apenas quando a condição não se verifica.
Agora vamos ver uma variante do programa acima, e espero que consiga adivinhar o que vai acontecer:

num = input('Escreve um número: ') if int(num) < 0:     print('O número é negativo') elif int(num) > 0:     print('O número é positivo') else:     print('O número é zero')

Aqui temos então o comando elif, que não é mais do que uma aglutinação de else if (mas não tente escrever else if, porque não funciona), e que permite analisar várias condições até encontrar uma que seja verificada. Por outras palavras, podemos escrever o número de comandos elif que quisermos (a seguir a um if inicial, claro!), que o Python verifica sequencialmente qual é a primeira condição verdadeira. (Caso seja um programador experimentado, posso desde já adiantar que o Python não tem uma estrutura do género select case, ou switch, pois uma sequência de if ... elif ... elif ... ... else substitui essa estrutura.)
Ok, antes de acabar, vou referir os vários operadores de comparação que existem: > (maior-do-que), < (menor-do-que), == (igual-a; repare que são dois sinais para distinguir de um igual de atribuição de variável), != (diferente-de), >= (maior-ou-igual-a), <= (menor-ou-igual-a). São 6 no total, e já dão para todas as comparações possíveis! E podem comparar-se cadeias de caracteres, inteiros, com casas decimais, ou mesmo booleanos! Toca a experimentar num programa ou mais para ver o que já consegue fazer!

Listas e ciclos

Na última mensagem já vimos (finalmente!) como se escreve um programa em Python e como se executa. Mas os comandos de que já falámos não são muito versáteis na quantidade de coisas que podemos fazer com eles. Antes de apresentar um novo comando, vou falar de uma estrutura de dados que é preciso compreender antes: a lista.
Uma lista não é mais do que um conjunto de objetos agrupados. Para criar uma lista, experimente:

>>> lista = [1, 2 ,4, 6 ,7] >>> lista [1, 2, 4, 6, 7]

Acabámos de criar uma lista! E pudemos ver o seu conteúdo completo. Mas imaginemos que queremos ver apenas o número 4. Para isso, escrevemos:

>>> lista[2] 4 >>> lista[2:4] [4, 6]

Claro que aproveitei e mostrei como escolher vários elementos da lista. O indexamento dos elementos da lista funciona da mesma maneira que nas cadeias de caracteres: por meio de slicing. E já agora, mostro como se referencia a partir do fim da lista (ou da cadeia de caracteres), independentemente do seu comprimento. Se fizermos:

>>> lista[-3:-1] [4, 6]

Isto é, o elemento mais à direita é representado pelo índice -1, o segundo mais à direita por -2, e por aí diante. E como antes, o primeiro elemento é incluído, e o elemento final não é, na definição do intervalo de slicing. Também podemos decidir que queremos ver a lista do início até dado ponto, ou de dado ponto até ao final, ou mesmo a lista completa:

>>> lista[:3] [1, 2, 4] >>> lista[3:] [ 6, 7] >>> lista[:] [1, 2, 4, 6, 7]

E que mais podemos fazer com listas? Bem, se quisermos, podemos mudar um dado elemento da lista:

>>> lista[2] = 10 >>> lista [1, 2, 10, 6, 7]

Também podemos remover um dado elemento da lista:

>>> del lista[2] = 10 >>> lista [1, 2, 6, 7]

E também podemos adicionar um dado elemento da lista:

>>> lista = lista + [11] >>> lista [1, 2, 6, 7, 11]

E agora, imagine que queria ver todos os elementos da lista um a um. Uma maneira seria escrever várias vezes lista[i], com i a ir de 0 até ao número de elementos menos 1. Mas felizmente existe uma maneira mais fácil. Vamos ver um programa:

nums = [1, 4, 5, 6, 3] for i in nums:     print(i)

Quando executar este programa (ainda se lembra como?), vai obter o seguinte resultado:

1 4 5 6 3

Bem vindo aos ciclos! Em outras linguagens de programação, definem-se ciclos for através de uma variável que vai sendo incrementada sempre da mesma maneira. No Python, o comando for serve para iterar todos os elementos de uma dada lista, um de cada vez. De notar que o que vai ser executado no interior do ciclo for (neste caso, a instrução print) está indentado (aqui está com 4 espaços), pois no Python a definição de blocos internos de código é feita com indentação, ao contrário de outras linguagens, onde se usam chavetas ou outros. Aqui usei 4 espaços, mas pode usar os espaços que quiser, desde que use sempre o mesmo número num dado bloco. Além disso, o início de um bloco é assinalado por dois pontos (:), que está no final da linha que contém o comando for.
E por hoje é tudo.

Print, Input e programar!

Ora cá estamos de novo.
Já vamos na sexta mensagem e na realidade ainda nem percebemos como se escreve um programa. Não desespere: hoje vamos finalmente abordar esse tema e no final já saberemos criar o proverbial programa que saúda o mundo!
Mas antes disso vamos falar de um dos comandos mais importantes em qualquer linguagem: o comando que nos permite visualizar coisas, que em Python é o comando print(). Mais uma diferença entre a versão 2.x e a 3.x: na versão 2.x não se usam os parêntesis, mas deixa-se um espaço entre o comando e o que se vai visualizar. Experimentemos então:

>>> print('Olá mundo!') Olá mundo!

Repare na diferença:

>>> 'Olá mundo!' 'Olá mundo!'

O comando print() apresenta o resultado visível do objeto, e permite a apresentação de textos a partir de um programa, enquanto a inserção direta no '>>>' apresenta o resultado das cadeias com as plicas em volta.

Vamos agora aprender um outro comando, que nos permite obter dados a partir do utilizador:

>>> input() 6 '6'

Agora é que dava jeito que estivesse a experimentar mesmo isto! É que o 6 acima é escrito por si quando escreve o comando input(), isto é, o Python está a pedir-lhe que escreva algo no teclado e que prima RETURN. E repare no resultado: tem plicas. Isto quer dizer que o que quer que seja que escrevemos é interpretado sempre como uma cadeia de caracteres. Mais um parêntesis: na versão 2.x, o input() só aceita valores numéricos, e temos o raw_input() para aceitar cadeias de caracteres. Na versão 3.x, o raw_input() já não existe.
Vamos agora experimentar:

>>> nome = input() Xico >>> nome 'Xico'

Aqui vemos que podemos atribuir o que obtemos através do input() a uma variável, e podemos consultar o seu valor de seguida. Outra maneira de o fazer é:

>>> print(nome) Xico

E se fizermos:

>>> idade = input() 10 >>> print(nome, idade) Xico 10

Atribuímos o valor '10' à variável idade, e de seguida no print() quando inserimos objetos separados por vírgulas, separa-os com um espaço.
Bem, acho que já temos material suficiente para escrever um primeiro programa. Como se faz isto? Bem, agora é que vai ser necessário uma de duas coisas:

• Estar a utilizar o IDLE do Python
• Utilizar um editor de texto como o Notepad do Windows

Se estiver a usar o IDLE, vá à barra de cima, e escolha File > New File, ou então prima CTRL+N. Vai abrir-se uma nova janela intitulada Untitled. Seja nesta janela, ou na janela do Notepad, escreva:

print('Olá, mundo!')

Tanto no IDLE como no Notepad, na barra de cima, escolha Save, e dê um nome ao ficheiro com extensão .py e grave-o onde lhe apetecer (mas memorize onde o gravou!). E já criou o seu primeiro programa! Para o correr, no IDLE, na janela do seu programa escolha Run, e verá o resultado a surigr na janela principal do IDLE. Para ver o resultado criado através do Notepad, terá de abrir uma Command Prompt, ir até ao directório onde gravou o ficheiro .py, e escrever o seu nome em conjunto com a extensão .py. Giro, não é? Foi o seu primeiro programa em Python!

Tipos de variável

Olá mais uma vez.
Vamos lá então voltar às variáveis. Lembra-se daquela diferença entre 6/2 = 3.0 ou 3? Sim, estes resultados têm um tipo diferente: 3.0 é um número de vírgula flutuante (isto é, permite casas decimais), enquanto 3 é um número inteiro. Se experimentarmos:

>>> type(3) <class 'int'> >>> b=2 >>> type(3.0) <class 'float'>

Resultado interessante, não é? A função type() devolve-nos o tipo do valor ou variável que lhe fornecemos: int para inteiro e float para vírgula flutuante. Outra diferença entre a versão 2.x e a 3.x: na versão 2.x, surge: <type 'tipo'>. Mais geralmente, a função type() devolve-nos o tipo (ou classe) de qualquer objeto, e veremos depois o que significa isto.
A principal diferença entre estes tipos de variável prende-se com o modo de armazenamento interno destes valores no computador. Além disso, de um modo geral as operações entre variáveis ou valores do mesmo tipo resulta no mesmo tipo, com a notável exceção da divisão de números inteiros que, como já vimos, em Python 3.0 resulta num número float. De momento, não dá para perceber qual a utilidade entre ter números inteiros ou de vírgula flutuante, mas veremos isso mais tarde, quando falarmos em enumeração.
Já agora, uma curiosidade: o Python permite utilizar também números complexos (ou imaginários). Para representar a parte imaginária, usa-se a letra j (e não a i, a que estamos habituados). Experimente:

>>> (3 + 5j) + (2 - 7j) (5-2j) >>> 3 + 5j + 2 - 7j (5-2j) >>> type(5-2j) <class 'complex'>

Alguns pormenores a ter em atenção: na primeira linha usei parêntesis só por claridade, pois como se percebe na segunda entrada não são necessários. E podemos ver que estes valores são do tipo complex.
Para resumir: operações entre inteiros podem resultar em inteiros ou de vírgula flutuante; entre inteiros e de vírgula flutuante resulta sempre em vírgula flutuante; entre valores em vírgula flutuante e complexos resulta sempre complexos.
Até agora, só vimos números. Mas existem outros tipos de valores: as cadeias de caracteres, que constituem texto. Estas são definidas colocando caracteres entre plicas ('') ou entre aspas (""). Por exemplo:

>>> "Olá mundo!" 'Olá mundo!' >>> letras = 'Olá mundo!' >>> letras 'Olá mundo!' >>> type(letras) <class 'str'>

Ora então o que temos aqui? Vemos que, como sempre, quando colocamos um valor em '>>>', obtermos como resultado esse valor. Embora tenhamos definido a cadeia com aspas, o resultado apareceu com plicas. Isto só muda se inserirmos alguma plica dentro do texto entre aspas. O objetivo de termos duas maneiras de criar as cadeias é para podermos inserir plicas ou aspas dentro do texto de modo mais fácil.
Também podemos criar variáveis com texto, e ver o seu conteúdo. e o tipo destes valores ou variáveis é str, diminutivo de string. Aqui estão mais umas coisas que se podem fazer com as cadeias:

>>> "Olá " + "mundo!" 'Olá mundo!' >>> "Olá! "*5 'Olá! Olá! Olá! Olá! Olá! ' >>> letras = 'abcdef' >>> letras[2] 'c' >>> letras[2:5] 'cde' >>> 'cde'[1] 'd'

Como seria de esperar, podemos concatenar cadeias. O que possivelmente já não estaria à espera é de poder multiplicá-las! Claro que só se pode multiplicar uma cadeia por um inteiro, e o resultado está à vista.
E finalmente, aquela coisa dos parêntesis retos ([]) é chamada de slicing (em português poderia traduzir-se por seccionamento, mas não me soa tão bem...), e pode usar-se com definição de um ou dois números: se usarmos um, vai buscar o caracter que se encontra na posição definida pelo número; mas atenção que a contagem começa com zero!! No exemplo acima, o caracter 'c' é o terceiro de letras, mas fica na posição 2 se contarmos a partir de zero. Quando se usam dois números separados por ':', o primeiro número aponta para a posição do primeiro caracter a incluir, e o segundo número indica qual o caracter onde se para, não incluindo esse. No exemplo acima, 2 é o terceiro caracter e 5 é o sexto ('f'), que já não foi incluído no resultado. A última linha mostra que podemos seccionar diretamente uma cadeia, não precisa de ser uma variável. Mais uma vez, isto não é tudo, e voltaremos a este assunto mais tarde...
E vamos terminar com o último tipo elementar de que falta falar: o booleano. Este só pode assumir dois valores: verdadeiro (True) ou falso (False). Sim, têm de ser com a primeira letra maiúscula.

>>> True True >>> True == False False >>> True != False True >>> type(True) <class 'bool'>

True é um valor com resultado True. Na segunda inserção, estamos a perguntar se True é igual a False, e como não são iguais, o resultado é False. Acabámos de apresentar outro operador: a igualdade (==), que resulta em verdadeiro ou falso. São dois sinais de igual, para não se confundir com a atribuição de variáveis, só com um sinal de igual. Podemos comparar várias coisas, como (mais uma vez) veremos mais tarde. Depois, temos o operador de desigualdade (!=), que verifica se dois objetos são diferentes. Finalmente, mostramos que o tipo destes valores é booleano ('bool').
E por agora chega.

Variáveis em Python

Cá estamos mais uma vez.
Até agora vimos que podemos usar o IDLE do Python como uma calculadora, mas claro que podemos fazer muito mais! Imaginemos que queremos usar sempre o mesmo valor para vários cálculos, por exemplo o valor de π = 3,14159265. Em vez de estarmos sempre a escrever todas estas casas decimais, podemos guardar este valor numa variável. Como? Veja o exemplo:

>>> pi = 3.14159265 >>> pi 3.14159265

O que aconteceu? Criámos uma variável de nome pi à qual atribuímos o valor 3,14159265, colocando o = a seguir ao nome da variável e finalmente o valor que lhe queremos atribuir (os espaços antes e depois do = são opcionais). Depois perguntámos qual o valor da variável ao escrever pi e obtivemos o resultado. Simples, não é? Repare que, se tivéssemos escrito pi antes de lhe atribuir um valor, iria resultar num erro:

>>> Pi Traceback (most recent call last):   File "<pyshell#5>", line 1, in <module>     Pi NameError: name 'Pi' is not defined

Mas, se já definimos pi, porque é que agora deu erro? Repare na diferença, o segundo foi escrito Pi, com letra maiúscula, e não pi. Sim, primeiro detalhe a reter: os nomes das variáveis são sensíveis à capitalização das letras. E quais são os nomes permitidos para variáveis? Bem, só podem conter as letras de a-z, A-Z, algarismos de 0-9 e o traço de sublinhado _; e o nome não pode começar por um algarismo. Assim, os nomes asd_27, _1uif, Python e aSd_27 são permitidos (e todos diferentes), enquanto $ers, 45asdf, perc% ou AAA-R não são permitidos.
E claro que agora podemos fazer cálculos com as variáveis criadas:

>>> pi*2 6.2831853 >>> pi*pi 9.869604378534024 >>> pi = pi + 3 6.14159265

Repare que, na última linha, alterámos o valor de pi ao adicionarmos-lhe 3. Daí o nome variável, porque o seu valor pode variar... que é o que mais acontece quando se programa.
Bem, e se quiséssemos atribuir o mesmo valor a várias variáveis? Uma maneira seria:

>>> a=2 >>> b=2 >>> c=2

Mas o Python tem uma maneira mais fácil de o fazer:

>>> a=b=c=2

Usando a sintaxe acima, atribuiremos de uma só vez o valor 2 a cada uma das três variáveis. Mas e se quisermos atribuir valores diferentes? Podemos fazê-lo do modo seguinte:

>>> um,dois,tres = 1,2,3 >>> dois 2

Assim, se separarmos variáveis com vírgulas e a seguir ao = colocarmos os valores a atribuir também separados por vírgulas, podemos fazer várias atribuições ao mesmo tempo. E se quisermos ver-nos livres de uma variável? Também o podemos fazer com:

>>> del dois >>> dois Traceback (most recent call last):   File "<pyshell#8>", line 1, in <module>     dois NameError: name 'dois' is not defined

Usando o comando del seguido do nome da variável, apagamo-la e perdemos o seu valor. Giro, não é? Mas da próxima vez vamos falar dos vários tipos de variáveis...

Python como uma calculadora

Muito bem, já chegámos até aqui e ainda não fizemos nada realmente em Python... mas hoje vamos finalmente começar a fazer alguma coisa.
Antes de mais, comecemos por abrir o IDLE do Python com: Start > Programas > Python X.x > IDLE (Python X.x).
Deverá aparecer uma janela com o seguinte conteúdo (ou parecido):

Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bit (Intel)] on win32 Type "copyright", "credits" or "license()" for more information. >>>

Muito bem: a seguir ao ">>>" abaixo está a piscar um cursor, que indica onde irão ser escritos os comandos. Experimente escrever "1+1", seguido de ENTER. Deverá aparecer o seguinte:

>>> 1+1 2 >>>

O que é que acabou de acontecer? Bem, perguntámos ao IDLE do Python quanto é 1+1 e ele apresentou o resultado: 2. Ao contrário de outras linguagens, em que temos de usar um comando para pedir para mostrar o resultado (um Print ou um Write, ou algo do género), aqui apenas temos de escrever o que queremos calcular. E surge nova ">>>" para aceitar um novo comando.
Do mesmo modo, os resultados seguintes são de esperar:

>>> 5-2 3 >>> 3*5 15 >>> 6/2 3.0

Assim, ficamos a saber como somar, subtrair, multiplicar (símbolo *) e dividir. Mas atenção! Reparou que 6/2 deu 3.0 e não 3? Bem, aqui surge uma primeira diferença entre o Python 3.x e o Python 2.x: no primeiro, a divisão entre dois números dá sempre como resultado um número com casa decimal, enquanto no Python 2.x o resultado é um número inteiro, ou seja, resulta numa divisão inteira. Por exemplo, em Python 2.x, 6/4 = 1. Se quisermos a divisão exata, teremos de escrever um dos números com casa decimal, do modo seguinte: 6.0/4 = 6/4.0 = 1.5. Voltaremos a isto quando falarmos em tipos de variáveis....
Por outro lado, em Python 3.x, se quisermos a divisão inteira, escrevemos:

>>> 6//4 1 >>> 6%4 2

E o sinal % serve, tanto em 2.x como em 3.x, para calcular o módulo, isto é, o resto da divisão inteira, como o exemplo acima demonstra. Finalmente, um último operador:

>>> 6**4 1296

Este é o operador de potência, isto é, 6*6*6*6 = 6⁴ = 1296. E como seria de esperar, os operadores têm precedência: ** antes de *, / e %, antes de + e -. Claro que podemos usar parêntesis para alterar a ordem em que os cálculos são efetuados:

>>> 1+2*3 7 >>> (1+2)*3 9 >>> 2**1/2 1.0 >>> 2**(1/2) 1.4142135623730951

De notar que, como se ilustra acima, podemos calcular raízes com potências fracionárias, como seria de esperar. Assim, já podemos usar o Python como uma calculadora! E por agora é tudo.

Os sabores de Python: como usufruir

Bem, se ficou convencido de que o Python deve valer a pena, então agora deve estar a pensar "onde é que eu arranjo isto?", e as linhas seguintes servem para o elucidar.

Conforme já foi referido, pode descarregar o Python de www.python.org. Mas atenção: existem duas versões de Python em uso corrente, a versão 2.x e a versão 3.x. A versão 3 surgiu em 2008 como resultado de o seu autor querer arrumar e limpar uma série de pontas soltas no Python. Assim, a versão 3.x não apresenta compatibilidade completa com a versão 2.x, isto é, código escrito em Python 2.x pode não ser compatível com o Python 3.x. E qual deve usar? Bem, a menos que tenha já um motivo específico para escolher a versão 2.x, deve avançar para a versão 3.x, pois a grande maioria das bibliotecas entretanto desenvolvidas já são compatíveis com esta versão. Eu vou centrar-me na versão 3.x, e sempre que necessário aponto as diferenças entre esta e a 2.x.

Esta bipolaridade de versões implica que tenha em atenção qual é a versão em utilização num dado ambiente ou fonte de informação que esteja a usar/consultar, para garantir que não se sentirá frustrado se um dado código não funcionar no seu ambiente de Python.

Muito bem, agora que já decidiu qual a versão a usar, vamos ver como se instala a coisa. Quando for ao endereço www.python.org, vai ver algo do género:

Aqui tem que clicar em Downloads e escolher a versão pretendida (vou falar apenas em ambiente Windows, que é o que domino) e descarregar o ficheiro python-x.x.x.exe. Execute-o, e vai aparecer uma janela do género da seguinte:

Claro que irão existir pequenas diferenças, de acordo com a versão que escolheu (2.x ou 3.x, 32 ou 64 bit), mas para instalar escolha a opção "Install Now", para todos os utilizadores, e adicionando o Python à PATH. Deixe instalar... e já está: já tem o Python instalado!
Ok, e agora? Bem, e que tal experimentarmos uma primeira linha de Python, só para termos a certeza que está a funcionar? Para isso, existem duas maneiras de o fazer:

• No Windows, em Start > Programas > Python X.x > Python X.x
Irá aparecer uma janela do género:

Alernativamente, experimente:

• No Windows, em Start > Programas > Python X.x > IDLE (Python X.x)
Irá aparecer uma janela do género:

Qual delas usar? Aparentemente parecem iguais, mas existem diferenças: enquanto a primeira permite essencialmente usar o interpretador de Python, a segunda tem uma barra de comandos muito útil que permite trabalhar com programas e módulos, entre outras coisas. Esta última é o IDLE, acrónimo de Integrated Development and Learning Environment, ou seja, Ambiente Integrado de Desenvolvimento e Aprendizagem (embora nunca tenha visto o acrónimo AIDA...).
Assim, use a primeira se quiser experimentar um comando rápido ou uma série deles; use o IDLE para desenvolver programas mais completos com mais facilidade. Para já, vou assumir que estamos sempre a usar o IDLE. Mais tarde, veremos que existem outros ambientes de trabalho... e por agora é tudo!

O que é o Python?

Olá.

Se está aqui, é porque já ouviu falar em Python. Se calhar, não sabe bem o que é e gostaria de saber, senão não estaria a ler isto. Então vamos lá.

Curiosamente, o Python é uma linguagem de programação bastante antiga, inventada no final de 1989 pelo holandês Guido van Rossum quando, alegadamente, "...não sabia muito bem o que fazer na semana de Natal...".
Mas se foi inventada há tanto tempo, porque é que agora anda a ser tão utilizada? Sim, está entre as linguagens mais usadas atualmente (Índice TIOBE)! Bem, existem vários motivos para isso:

• É fácil de aprender: a sua sintaxe é bastante simples e de fácil leitura;
• Pode ser interpretada ou compilada: ao contrário de linguagens como o Java ou o C, o Python tem um interpretador que permite inserção de comandos com resultado imediato; não é necessário escrever todo um programa, compilá-lo e só então ver onde estão os erros ou obter os resultados;
• É portável: um programa escrito em Python pode ser utilizado em várias plataformas (Windows, Mac ou Linux) praticamente sem alterações;
• É extensível e modular: com o advento das aplicações computacionais em larga escala (o Big Data, o Machine Learning, etc.), foram criadas e disponibilizadas publicamente bibliotecas próprias para lidar com estes problemas (NumPy, ScyPy, Pandas, etc...) que facilitam imenso o trabalho de tratamento e apresentação de dados; todas estas bibliotecas podem ser usadas como módulos que se acrescentam sem esforço ao nosso próprio código;
• É gratuita e de código aberto: o interpretador/compilador de Python pode ser descarregado em www.python.org, e quem quiser pode contribuir para o seu desenvolvimento (daí todas as bibliotecas já existentes).

E, claro, a cereja no topo do bolo é o seu nome: foi inspirado nos Monty Python...

Muito bem, acho que isto chega como introdução, e espero que fique com vontade de saber mais! A próxima publicação vai explicar como instalar isto no seu computador.