O que iremos cobrir? |
---|
|
Em qualquer actividade criativa, nós precisamos de 3 coisas básicas, são elas, ferramentas, materiais e técnicas. Por exemplo, quando estou a pintar as minhas ferramentas são os pincéis e os lápis, técnicas são 'washes', 'wet on wet', spraying, etc... E finalmente os materiais são as tintas, a tela, etc.... De uma forma muito semelhante quando estou a programar as minhas ferramentas são, as linguagens de programação, o hardware e os sistemas operativos. As técnicas são, pelo menos algumas, aquelas que estivemos a ver até aqui. E o material são os dados que manipula-mos. Este capitulo vai ser centrado na matéria-prima da programação.
Isto vai ser uma secção muito longa, por vezes podes mesmo acha-la um tanto ou quanto seco, isto para não dizer chato. Mas as boas noticias são que não iras precisar de ler tudo de uma assentada. Este capitulo vai começar aso tipos de dados mais básicos que podemos encontrar, depois fala-nos como havemos de lidar com bibliotecas de dados e finalmente por fim falamos de uns conceitos já mais avançados. Em caso que queiras saltar do barco (nem que seja para ir tomar um café), recomendo que o faças depois da secção sobre as bibliotecas, e se quiseres podes mesmo ler o capitulo seguinte do tutorial, mas não te esqueças que tens que aqui voltar, porque os conceitos mais avançados precisam que saibas isto.
Dados ou data, é um daqueles termos que toda a gente usa, mas poucos são o qual o seu significado. O meu dicionário
diz o seguinte:
"factos ou números, dos quais conclusões podem ser tiradas; informação"
Não sei se ficaste muito mais elucidado, mas pelo menos já tens um ponto de partida. Vamos ver se conseguimos clarificar as coisas olhando para como os dados são encarados do ponto de vista programacional. Dados são os ingredientes, a informação nua e crua, que o teu programa mais tarde irá manipular por forma a torna-lo algo de interessante. Mas sem dados para manipular os programas também não fazem nada de interessante. Programas podem manipular dados de varias formas, muitas das vezes dependendo apenas do tipo de dados. Cada tipo de dados por sua vez tem um número de operações - ou seja formas que se pode manipular - por exemplo já vimos que podemos adicionar números, então a adição é um operador de um tipo de dados que são os números. Dados têm vários tipos, o que nos nos vamos propor a fazer é analisar as mais comuns e os operadores que podemos usar nesse tipo de dados:
Os dados são guardados na memória do computador, podes ver isso como sendo uma sala dos correios cheia de caixas para separar o correio, agora imagina as variáveis como sendo o rotulo dessas caixas, sim porque se essas caixas não tivessem rotulo, ai seria a confusão geral. Então as variáveis são os rótulos na memória na do computador, indicando onde dados estão guardadas.
Para podermos manipular os dados, nós iremos precisar de acede-la, e para isso é que servem as variáveis. Em termos nós criamos instances (é como tirar uma fotografia) dos vários tipos de dados e depois usamos variáveis para os rotular. Uma variável é uma referência para uma aérea especifica na memória do computador onde os dados estão guardados. Em algumas linguagens de programação existem vários tipos de variáveis, como vários tipos de dados, fazendo que um determinado tipo de variável só possa ser usado com determinado tipo de dados, e qualquer tentativa de mudar essas regras do jogo resultam em erro. Existem alguns programadores que preferem este sistema, conhecido como static typing (escrita estática) porque ajuda a prevenir os bugs mais subtis, que são os mais difíceis de detectar.
Mas no Python isso não acontece, uma variável aceita qualquer tipo de dado que lhe destines, mas avisa-te quando já estás a misturar dados de uma forma estranha - como quereres adicionar um número a uma string. Podemos mudar o tipo dado para a qual a variável esta apontar, simplesmente redireccionando a variável para um outro tipo de dado.
>>> q = 7 # atribuímos o q a um número >>> print q 7 >>> q = "Sete" # agora atribuímos o q a uma string >>> print q Sete
Como podes ver o q estava a apontar para o número 7 inicialmente, até que nós o mandamos apontar para a string 'sete'. confirmando o que foi dito acima que para mudar o tipo de dado a que uma variável esta a apontar, basta redirecciona-la. Quando esse redireccionamento acontece, o dado inicial é 'perdido' e o Python apaga-o da memória (a não ser que existam 2 variáveis a apontar para o mesmo dado) isto é conhecido como Garbage collecction (a colecção do lixo - a colecção que vai para o lixo, seria uma tradução melhor).
Garbage collecction pode ser associado com o empregado dos correios, que aparece de vez em quando e, tira todos as cartas que não tem morada, pois para ele se uma carta não tem morada, não serve para nada, então, lixo. Agora vamos dar uma olhadela a alguns tipos de dados para ver como tudo isto funciona.
Os tipos de dados primitivos, são assim chamados porque de todos os tipos de dados que podemos manipular estes são sem duvida os mais básicos. Os outros tipos de dados mais complexos, são apenas combinações do tipo primitivo. Podemos dizer que são a fundação onde os outros dados podem ser construídos. Neste tipo de dados podemos incluir as letras, os números e uma outra categoria a que chamaremos de Boolean.
Estes já foram vistos. Neste grupo incluímos todos os caracteres ou sequência de caracteres, desde que possam ser dispostos no ecrã ( mas, nesta categoria, ainda podemos incluir alguns caracteres que não podem ser impressos os chamados control characters).
No Python as strings podem ser representadas de varias maneiras:
com aspas simples:
'Aqui esta uma string'
Com aspas duplas:
"Aqui esta uma outra string muito semelhante"
Com triplas aspas:
""" Aqui esta uma string muito, mais longa que que as anteriores, e pode ser disposta com todas as linhas que escrevemos preservando a forma como elas foram escritas..."""
Um uso especial para este último é a construção da documentação das funções do Python que nós mesmos criamos - mas isso veremos mais tarde.
É-nos permitido aceder aos caracteres de uma string individualmente, tratando-as como uma array . Normalmente existe sempre um determinado número de operadores, fornecidos pela linguagem de programação, que nos ajudam a manipular melhor as strings - como por exemplo ajudam-nos a encontrar sub strings, juntar duas string, copiar de uma string para outra etc....
Operador | Descrição |
---|---|
S1 + S2 | Concatenação de S1 e S2 |
S1 * N | N repetições de S1 |
Agora vamos vê-los em acção:
>>> print 'Vezes' + 'sem conta' # concatenação de string Vezes sem conta >>> print 'Repete ' * 3 # repetição de string Repete Repete Repete >>> print 'Sem conta' + ('vezes e vezes' * 3) # combine '+' and '*' Sem conta vezes e vezes vezes e vezes vezes e vezes
Também podemos atribuir uma variável a uma string, assim:
>>> s1 = 'Sem conta ' >>> s2 = 'vezes e vezes' >>> print s1 + (s2 * 3) Sem conta vezes e vezes vezes e vezes vezes e vezes
Repara que os dois últimos exemplos produziram o mesmo resultado.
DIM MyString$ MyString$ = "Olá Mundo!" PRINT MyString$
O Tcl usa as strings de uma forma interna, do ponto de vista do utilizador, isso nem sempre é assim tão obvio. Quando queres criar uma string, uma forma de o fazeres é pô-la entre aspas. Para atribuíres uma variável tens que usar o comando set e para teres acesso a essa variável, simplesmente terás que por o símbolo $ a frente do nome da variável, ora vê:
% set Mystring "Olá Mundo" % put $Mystring
Nota: Tanto no Tcl como no BASIC somente aspas duplas podem ser usadas nas strings.
Integras são números inteiros que vão desde um determinado valor negativo até a um determinado valor positivo, isto que acabei de dizer é algo que que vocês decorem pois é muito importante, vamos em frente. Normalmente não pensamos números como estando restritos a um tamanho ou a um valor se quiserem, mas como estamos a falar de computadores, têm que existir limites. Limite para o número mais baixo e um limite para o número mais alto. O limite para o número mais alto que se pode utilizar chama-se de MAXINT e depende do número de bits que o teu computador usa para representar um número. Na maioria dos computadores são 32 bits, o que faz com que o MAXINT seja volta dos 2 bilhões..
Números com valores positivos e números com valores negativos são conhecidos como signed integers. Também podemos obter uma outra coisa chamada de unassigned values, ou seja um grupo de números, mas apenas com valores positivos neste grupo incluímos o zero. Isto significa que imediatamente ficamos com um novo um limite para o número mais alto que será de 2* MAXINT ou 4 bilhões, num computador de 32 bits, isto porque agora podemos utilizar o espaço anteriormente reservado para números negativos para guardar mais números positivos.
Mas como as integras estão restritas em tamanho pelo MAXINT, a adição entre duas integras e onde o resultado dessa adição resulte um número maior que o MAXINT irá dar erro. Normalmente quando é causado um erro, das duas uma, ou o programa tenta lidar com ele, ou então o programa fecha. No Python esta última e a opção adoptada, enquanto no Tcl a primeira opção foi a escolhida. o BASIC, diz-nos que existe um erro, mas não nos indica como 'caça-lo' (pelo que eu saiba)
Nos já vimos todos os quase todos operadores aritméticos na secção das Sequências Simples, mas façamos uma recapitulação:
Exemplo | Descrição |
---|---|
M + N | Adição de M e N |
M - N | Subtracção de N do M |
M * N | Multiplicação de M pelo N |
M / N | Divisão de integras ou números fraccionários. |
M % N | Modulo: encontra o resto na divisão M pelo N |
M ** N | Potências: M elevado a potência de N |
Como ainda não vimos o último operador em acção, vamos por isso a um exemplo para que possamos ver como utiliza-lo melhor:
>>> i1 = 2 # criamos a integra 2 a qual atribuímos a variável i1 >>> i2 = 4 >>> i3 = 2 ** 4 # atribuímos o resultado de 2 elevado a 4 a variável i3 >>> print i3 16
O BASIC já contém mais algumas regras que o Python para lidar com integras. já foi dito que se quisermos atribuir uma integra a uma variável no BASIC, podemos utilizar um texto simples, ou então usar um nome terminando com o símbolo % (pessoalmente recomendo, porque penso que o interprete reconhece as coisas mais rapidamente assim):
FOO = 8 REM podemos atribuir a variável FOO a qualquer tipo de número BAR% = 9 REM só nós é permitido atribuir integras a variável BAR
Uma última coisa relativamente as integras no BASIC:
i% = 7 PRINT 2 * i% i% = 4.5 PRINT 2 * i%
Repara que quando atribuímos o 4.5 ao i, nada de estranho pareceu acontecer, mas na realidade só a parte inteira do número fica atribuída a variável, isto provavelmente te faz lembrar a divisão com números decimais no Python. Como te foi dito na altura, todas as linguagens de programação têm estas pequenas particularidades.
Como acima mencionado, o Tcl guarda tudo internamente como strings, contudo isso não faz muita diferença ao utilizador porque quando se acede aos números o Tcl faz a conversão, por detrás das cortinas, sem que nós nos aperceba-mos disso. Mas as restrições relativas ao valores mais altos e mais baixos, ainda se aplicam.
O uso de números no Tcl, é ligeiramente mais complicado do que em outras linguagens, uma vez que para poderes fazer cálculos, tens que dizer ao interprete que vais fazer um calculo. Uma forma de avisar o interprete é usando o comando expr:
% put [expr 6 + 5] 11
Tudo que é colocado dentro de parêntesis rectos no Tcl é avaliado e executado em primeiro lugar, como se tivesse sido colocado na linha de comandos. Ao fazer isso o Tcl vê o comando expr, e faz o calculo. O resultado depois "posto" no ecrã através Em caso que tentes executar o calculo sem o expr, usando somente o comando put, o Tcl imprimiria, neste caso "6+5":
% put 6 + 5 6 + 5
Estes são fracções. Representam números de grande magnitude, muito maiores que o MAXINT, mas com menos precisão. Isto para dizer que 2 números reais, que supostamente deveriam ser iguais, podem não o ser quando comparados por um computador. Isto porque o computador faz os arredondamentos a partir de um certo grau. Por exemplo o 4.0 poderia ser representado por um computador como sendo 3.99999999... ou então 4.00000...01. Estes arredondamentos no entanto não interferem com a maior parte das nossas aplicações, mas ocasionalmente podem tornar-se num grande sarilho. Portanto se algum dia obtiveres resultados não esperados quando estiveres a usar números reais, mantém o isto em mente.
Os números fraccionários ou floating point numbers têm os mesmos operadores que as integras, com a capacidade extra de criar um valor que é uma integra.
Em caso que tenhas um background cientifico ou matemático, poderás estar a pensar, então e os números complexos? Em caso que não tenhas um background desses, provavelmente então nem sequer ouviste alguma vez falar de tal coisa. De qualquer das maneiras existem algumas linguagens de programação que fornecem funções built-ins para trabalhar com números complexos, nessas linguagens podemos incluir o Python e antes que perguntes o mesmo se aplica a matrizes.
No Python um número complexo é representado da seguinte forma:
(real + imaginário)
Para fazer uma adição será assim:
>>> M = (2+4j) >>> N = (7+6j) >>> print M + N (9+10j)
Todos os operadores usado nas integras podem aplicar-se aos números complexos..
Tal como diz no titulo, este tipo suporta apenas 2 valores - ou verdadeiro ou falso. Algumas linguagens têm um suporte directo para valores Boolean, enquanto outras usam uma convenção, onde normalmente um valor numérico (na maior parte da vezes o 0) representa falso enquanto outro valor numérico (usualmente o 1) representa verdadeiro.
Os valores de Boolean são por vezes conhecidos como os valores verdade, isto porque eles são usados para testar se algo é verdadeiro ou falso. Por exemplo imagina que crias um programa que faz um back up de todos os ficheiros numa determinada directoria, esse programa funcionaria da seguinte forma, fazia um back up de um ficheiro e depois perguntava ao sistema operativo pelo nome do próximo ficheiro. Quando não houvesse mais ficheiros para guardar o sistema operativo respondia com uma string vazia. Então o que o teu programa faria era testar para ver se o nome era uma string vazia ou não, guardando o resultado (verdadeiro em caso que a string seja vazia). Mais a frente verás como usar esse resultado.
Exemplo | Descrição | Efeito |
---|---|---|
A and B | AND | Verdadeiro se ambos A, B forem verdadeiros, doutra forma falso. |
A or B | OR | verdadeiro se um ou ambos forem A, B verdade, falso se A e B falsos |
A == B | Igualdade | verdadeiro se A for igual a B |
A != B ou A <> B | Diferente | Verdadeiro se A é diferente B. |
not B | Negação | Verdadeiro se B não for verdadeiro |
Nota: que o último operador funciona somente para um dos valores, enquanto os outros operam sobre os 2 valores.
As Ciências computacionais desenvolveram uma complexa disciplina de estudo a volta das colecções e dos seus comportamentos. Por vezes estas as colecções podem ter o nome de contentores. Nesta secção vamos ver os tipos de colecções existentes no Python e só depois iremos fazer um pequeno sumário sobre os tipos de colecções que se pode encontrar nas outras linguagens.
Uma lista, é simplesmente uma sequência de itens. O que a faz diferente de uma array é que a nas lista pode-se continuamente ir-se adicionado mais itens. Como o lado mau disso, é que as listas não contém uma forma de índice, portanto quando queres encontrar um dos itens, tens que ir a procura, verificando item por item. Tanto o Python como o Tcl têm módulos de listas que já vêem como parte da linguagem. No BASIC o caso já é diferente, e obriga-nos a ter que fazer programação muito complicada por forma a podermos simular uma. Os programadores de BASIC na maior parte das vezes acabam é por criar array muito grandes. A grande vantagem que o Python leva as outras linguagens é que ele cria um ince das suas listas, o que como veremos mais adiante, é uma coisa muito útil.
O Python tem muitos operadores que trabalham com colecções, e quase todos eles com listas. Ainda existe um outro grupo de operadores que trabalham somente com alguns tipo de listas como as strings, que no fundo são uma lista de caracteres. Para criar e aceder uma lista no Python usa-se parêntesis rectos. Podes criar uma lista vazia, usando um par de parêntesis rectos sem nada lá dentro, mas em caso que queiras lá colocar vários elementos podes separa-los usando uma virgula:
>>> aLista = [] >>> outra = [1,2,3] >>> print outra [1, 2, 3]
Podemos aceder aos vários elementos de uma lista, usando um índice numerário, onde o 0 equivale ao primeiro elemento da lista, o número do valor a aceder deve estar dentro de parêntesis rectos:
>>> print outra[2] 3
>>> outra[2] = 7 >>> print outra [1, 2, 7]
E também podemos usar números negativos para aceder a lista, isto tem como regra que o -1 é sempre o último valor da lista:
>>> print outra[-1] 7
Uma forma de adicionar valores a lista é usando o operador append():
>>> aLista.append(42) >>> print aLista [42]
Até podemos colocar uma lista dentro de uma outra lista:
>>> aLista.append(outra) >>> print aLista [42, [1, 2, 7]]
Repara em como o resultado é uma lista de 2 elementos, e o segundo elemento apresenta-se como uma lista (ou seja dentro de []) Isto é útil uma vez que nos permite criar representações de tabelas e grelhas usando listas dentro de listas. Podemos aceder aos elementos da segunda lista usando uma forma de duplo índice::
>>> print aLista[1][2] 7
O primeiro elemento do índice extrai o segundo elemento da, que por sua vez também é uma lista, o segundo índice extrai o terceiro elemento da sub lista.
O oposto de adicionar elementos, é remove-los, como é claro, para fazer isso usamos o comando del:
>>> del aLista[1] >>> print aLista [42]
Em caso que queiras juntar duas listas podes usar o operador da concatenação '+', tal qual como fizemos com as strings:
>>> novaLista = aLista + outra >>> print novaLista [42, [1, 2, 7], 1, 2, 7]
Da mesma forma podes usar o operador * para criar múltiplos do mesmo valor dentro da mesma lista:
>>> zeroLista = [0] * 5 >>> print zeroLista [0, 0, 0, 0, 0]
E finalmente, para determinar o tamanho de uma lista podes a usar a função len():
>>> print len(aLista) 2 >>> print len(zeroLista) 5
O Tcl também tem já vem com um módulo built In de listas, e junto com uma variedade de comandos para trabalhar nessas listas. Esses comandos são identificados pelo prefixo 'l' como por exemplo linsert, lappend, lindex, etc. Aqui esta um exemplo de como criar uma lista e aceder a uma lista no Tcl:
% set L [list 1 2 3] % put [lindex $L 2] 3
É uma função que não existe em todas as linguagens, mas naquelas em que se pode encontrar, é extraordinariamente útil. Um tuple não é mais que uma colecção de valores que são tratadas como uma só. Tuple e listas são semelhantes em muitos aspectos, com a grande excepção de Tuple são imutáveis, que é o mesmo quer dizer que são se pode alterar os seus constituintes, nem adicionar-lhe novos valores uma vez criado. No Python Tuple são simplesmente representados por um par de parêntesis, e os valores são separados por virgulas, assim:
>>> aTuple = (1,3,5) >>> print aTuple[1] # o índice funciona como nas listas 3 >> aTuple[2] = 7 # erro, não podes alterar os elementos de um tuple Traceback (innermost last): File "", line 1, in ? aTuple[2] = 7 TypeError: object doesn't support item assignment
O principal a manter em mente, pelo menos neste nível, 'e que um tuple é criado usando parêntesis normais. e é acedido usando-se parêntesis rectos. O acesso aos itens funciona da mesma forma como nas listas, usando-se um índice numerário. Mais uma vez repito que dos Tuple são imutáveis uma vez criados, de outra forma são tal e qual as listas. A maioria dos operadores das listas, também se aplicam aos Tuple.
Um dicionário, tal como o nome sugere contem um valor associado a uma chave, da mesma forma que um dicionário associa um determinado significado, a um determinado nome. os valores podem ser acedidos usando essa chave. As chaves podem ser desde string como qualquer outro objecto, desde que possa ser considerado um objecto imutável, como números e tuple. Ou seja quase todos os tipos de data que o Python usa. O dicionários normalmente são utilizados internamente, através de uma avançada técnica de programação chamada tabela hash. Por essa razão por vezes pode-se referir-se a dicionários usando a palavra hash. Lamento informa que não tem nada a haver com drogas!
Porque o acesso a dicionários é através de uma chave, tens que te certificar que cada valor tem um chave e essa chave é única. Os dicionários são imensamente úteis, no diz respeito as estruturas do código, e no Python já vêem como um módulo built In, mas em outras linguagens terás que ser tu a aceder a esse módulo, ou as vezes terás que ser tu a criar um. Dicionários podem ser usados em diversas coisas, e estou certo que teremos muitas mais adiante, mas por agora deixo-vos com este simples exemplo:
>>> dict = {} >>> dict['boolean'] = "um valor que só pode ser verdadeiro ou falso" >>> dict['integer'] = "um número inteiro" >>> print dict['boolean'] um valor que só pode ser verdadeiro ou falso
Repara em como iniciamos um dicionário braces, mas depois utilizamos os parêntesis rectos que aceder e adicionar valores.
Devido a estrutura interna dos dicionários, muitos dos operadores que já estudamos não são utilizados. Nada de concatenação, repetição e outros operadores. Existe uma função especifica para se aceder as chaves de um dicionário, função essa que é o Keys() (chaves), que uma vez digitada imprime todas as chaves validas de um dicionário.
Em caso que comeces a ficar um bocado cansado, podes passar para o próximo capitulo aqui Mas não te esqueças de voltar porque nos capítulos mais avançados iremos fazer uso de alguns tipos de data com tu ainda não estas familiarizado.
Uma lista de itens que usam um índice que permite um acesso fácil e rápido. Normalmente nestes casos já tens que saber de antemão quantos itens vão fazer parte do array ou vector. Por exemplo imagina que tens um array chamado A, quando quiseres aceder a um dos itens, por simplesmente digitas A[3]. Arrays são uma parte fundamental do BASIC, visto que são o único tipo de colecção que o BASIC suporta. No Python os array podem simulados com as listas, e no Tcl é com o uso de dicionários.
Um exemplo de um Array no BASIC, há-de ser assim:
DIM Myarray(20) REM cria uma array para 20 elementos
MyArray(1) = 27
MyArray(2) = 50
FOR i =1 TO 5
PRINT MyArray(i)
NEXT i
Repara que no BASIC o índice numerário começa no 1, o que é muito pouco usual, visto na maior parte das outras linguagens o índice começa sempre no 0. Bom e é tudo quanto a array, não existem operadores, nem mais nada, tudo que és permitido fazer é cria-los, atribuir-lhes valores e depois aceder a esses valores.
Isto seria traduzido (como já devem ter reparado detesto traduzir nomes) qualquer coisa como uma pilha. Imaginem uma pilha de bandejas num restaurante o empregado de mesa coloca uma pilha de bandejas limpas num determinado sitio, onde os clientes as vão retirando. Como é obvio os clientes vão tirando as de cima primeiro, o que faz com que as debaixo sejam tiradas por último. Bom com os dados exactamente a mesma coisa, colocas um item num stack ou podes tirar um. O item tirado é sempre o último que foi lá colocado (a mesma analogia que as bandejas). A esta propriedade das Stack dá-se o nome de LIFO - Last In First Out (Último a chegar, primeiro a sair - O empregado ideal). Uma outra propriedade dos stacks é que sempre que quiseres podes inverter a ordem dos itens. Os Stack não vêem coo módulos built In, nem no Python, BASIC ou Tcl. Tens fazer um bocado de programação para implementar esse comportamento nessa linguagens. Mas as listas são um melhor ponto de começo visto que tal como os stacks, podem crescer conforme as necessidades.
Bags são apenas de itens sem nenhuma ordenação especifica, e podem conter itens duplicados. Os bags normalmente tem operadores próprios que os permitem adicionar, remover, adicionar o encontrar itens. No caso do Python e do Tcl são são apenas Listas, no BASIC terás de as construir a partir de array muito grande.
Os sets ao contrario dos bags não podem conter duplicados, existem operadores que nos permitem testar para verificar se um determinado itens já faz parte de um set ou não. Nenhuma das nossas linguagens tem o módulo de set built In mas podemos facilmente simula-las tanto no Python como no Tcl através do uso de dicionários.
Os Queue são tal como os Stack, excepto que o primeiro item a entrar é o primeiro a sair (tal como numa fila, o primeiro a chegar é o primeiro a ser atendido), a isto dá-se o nome de FIFO First in First Out.
Existem muitos outros tipos de colecções, mas estes são os principais e os que irás encontrar mais frequentemente (na realidade nós nem vamos lidar com todos eles, neste tutorial)
Como um utilizador de computadores, deves saber tudo que precisas de saber - os ficheiros são a base de quase tudo que fazemos com computadores, portanto não vais ser surpresa nenhuma em saberes que a maioria das linguagens e programação tem um tipo de próprio de ficheiros para guardar dados. Contudo o processamento de ficheiros é tão importante que irei deixar isso para mais tarde, onde irei dedicar uma secção inteira a esse facto.
Datas e horas normalmente são um tipo de dados muito específicos, em qualquer que seja a linguagem. Mas muitas outras vezes são simplesmente representados como um número muito grande (na maior parte das vezes como sendo um número de segundos de uma determinada data). Noutros casos é um tipo de dado que é conhecido como o o tipo complexo que é descrito na próxima secção. Quando é com este tipo de dados, normalmente fica mais fácil de extrair o mês, dia, horas, etc..
Em algumas ocasiões os tipos básicos de dados descritos nas secções anteriores, por e simplesmente são inadequados para certas operações, mesmo quando esse tipos são combinados em colecções. O que por vezes queremos é juntar várias peças de informação de trata-las como se fossem uma peça só. como exemplo vamos usar uma morada. Onde existe um número de porta, o nome da rua, o nome da cidade, etc...
A maior parte das linguagens permitem-nos agrupar toda esta informação numa estrutura ou record.
No BASIC esse record teria mais ou menos este aspecto:
Type Morada Hs_Porta AS INTEGER Rua AS STRING Cidade AS STRING codigo_postal AS STRING End Type
No Python sseria ligeiramente diferente:
class Morada: def __init__(self, P, Rua, Cidade, Codigo): self.Hs_Porta = p self.Rua = rua self.Cidade = Cidade self.Codigo_postal = Codigo
Isto pode-te parecer um tanto ou quanto estranho, mas não te preocupes, eu irei explicar o significado do def __init(...) e do self na secção sobre programação orientada a objectos. Em caso que tenhas tentado introduzir o exemplo acima no Python certifica-te que também copias a indentação como deve ser, porque não sei se já reparaste que o Python é muito exigente quanto a isso..
O que eu quero que te apercebas aqui, e é muito importante que isso aconteça, é que juntamos vários tipos de dados numa só estrutura
Também é possível atribuir uma variável a um tipo de complexo de dado, mas para aceder os campos específicos, terás que usar um mecanismo especial (que varia de linguagem para linguagem), geralmente costuma ser um ponto . .
Mas continuando com o nosso exemplo da morada o BASIC seria assim:
DIM Mor AS Morada Mor.Porta = 7 Mor.Rua = "Rua da minha casa" Mor.Cidade = "MinhaCidade" Mor.Codigo_Postal = "123-456" PRINT Mor.Porta," ",Mor.Rua
E no Python:
Mor = Morada(7,"Rua da minha casa","Minhacidade","123-456") print Mor.Porta, Mor.Rua
O que aconteceu na realidade, foi que criamos, digamos que um instantâneo, e atribuirmos esse instantâneo a uma variável. e para depois imprimirmos os campos simplesmente teremos que usar o operador ponto.
A aproximação mais próxima que o Tcl consegue fazer dos tipos complexos é guardando os os campos numa lista. Mas depois terás que lembrar da sequência em que os introduziste por forma a que possas acede-los. Isto poderá ser simplificado se atribuíres variáveis as campos, variáveis essas que têm que ser números, como neste exemplo que se segue.
set Porta 0 set Rua 1 set Cidade 2 set codigo 3 set addr [list 7 "Rua da minha casa" "Minhacidade" "123-456"] puts [format "%s %s" [lindex $Mor $Porta] [lindex $Mor $Rua]]
Nota o uso de format strings e de agrupamentos de '[]'
Os tipos de dados definidos pelo utilizador, podem, em certas linguagens contém operadores, definidos pelo utilizador também. Isto é que é a base do que é conhecido como programação orientada a objectos. Mais adiante iremos dedicar uma secção inteira a este tópico, mas por agora o que é essencial manteres em mente é o seguinte, objectos são como uma colecção de dados juntamente com os seus operadores, todos juntos funcionando como se fossem uma unidade. O Python usa objectos de uma forma extensiva nas suas bibliotecas de módulos, e também permite ao programador/a que crie e utilize os seus próprios objectos.
As operações com objectos são acedidos da mesma forma que os operadores definidos pelo utilizador, através do operador ponto. Tirando isso são como funções, e têm o nome de métodos. Nós já vimos um destes métodos com o append(), quando estivemos a ver os operadores das listas . Mas não te esqueças que junto ao nome da função vai o nome da variável:
>>> listadeObjectos = [] # uma lista vazia >>> listadeObjectos.append(42) # usando um das vários métodos existentes na lista >>> print listadeObjectos [42]
Quando um objecto com o nome de class vem dentro de um módulo, esse módulo terá que ser importado, em caso que o queiramos utilizar (tal como fizemos com sys): Uma vez importado para o podermos utilizar basta colocar o nome do objecto e como prefixo do módulo, e voilá, criamos um instantâneo que podemos, se quisermos, atribuir a uma variável, para ser usado mais tarde. Quando usamos essa variável, já não necessitamos de ter como prefixo o nome do módulo.
Vamos exemplificar isso, para podermos ver melhor, para isso vamos imginar um módulo ficticio de receitas:
>>> import receita >>> Minhareceita = receita.minha() # para criar uma instance usamos o nome do módulo >>> Minhareceita.slice() # usa um dos operadores da tua Minhareceita >>> print Minhareceita.ingredientes # para aceder aos dados da minhareceita {Costoletas:40%, Fiambre:45%, Gordura:15%}
A não ser pela (grande) vantagem de podermos criar instantâneos que podemos guardar em variáveis, não existe assim uma grande diferença entre usar os objectos que vem dentro de um módulo ou funções dentro de um módulo. Pensa no objecto como sendo uma etiqueta numa caixa onde se guardam os funções e as variáveis.
Uma outra maneira de ver as coisas é pensar nos objectos como sendo representações do mundo real, coisas em que os programadores podem trabalhar e fazer coisas ainda mais interessantes. Foi a partir desta ideia é que surgiram os objectos nas linguagens de programação. Para ajudar a criar simulações no computador de situações reais.
tanto o QBASIC como o Tcl não suportam objectos. Mas no entanto existem módulos que podes encontrar e adicionar ao Tcl e te permitiriam trabalhar com objectos, o mesmo pode-se dizer do Visual Basic, O o mais moderno dos dialectos BASIC.
Neste tutorial o meu objectivo é ensinar-te a programar e apesar de usar o Python mais do que as outras, não existe
nada que te impeça de quando acabares isto, ires a procura de um outro tutorial sobre uma outra linguagem, e usar
essa linguagem mais tarde. Para dizer a verdade é exactamente isso que eu espero que faças
uma vez não existe
nenhuma linguagem de programação, nem mesmo uma tão poderosa quanto o Python, que te permita fazer tudo quanto queres.
Por esse facto é que eu aqui não menciono todas as capacidades do Python, mas sim o que faço é mostrar as capacidades
que não só existem no Python como em muitas outras linguagens também. Isto, é claro que também temo seu lado mau, que é
ficarem muitos dos operadores de fora. Entre esses operadores de certeza que irão encontrar
alguns que são muitos úteis e muito poderosos.
Finalmente, acho que também vale a mencionar isto, apesar destas particularidades e ter as dito com sendo do Python, isto
não quer dizer que não irás encontra-las em outras linguagens, o que te posso garantir é que não irás encontra-las
em todas as linguagens. No entanto todos os outros operadores que foram mencionados acima, posso te dizer que
quase com toda a certeza os irás encontrar em todas as linguagens de programação.
Bom agora que já temos um melhor conhecimento sobre a matéria prima da arte da computação, vamos por mãos a obra e ver
toda esta teoria que estivemos a aprender em pratica.
Anterior 
Próxima  Índice
Pontos a lembrar
Em caso que tenhas alguma dúvida ou queiras comentar esta página
envia-me um e-mail para:
babyboyd@oninet.pt